Repository navigation
Description
Context
Follow-up to #27's maintainer ruling (2026-10-23): choose B, view-only graceful degradation for now, and keep an issue to investigate a possible Hooks abstraction. A general callback/lifecycle boundary remains deferred, not solved by the view work. The earlier proposal is recorded on #27.
At reviewed main 15cac4c2, services register callbacks directly with WordPress; src/Infrastructure/ServiceBasedPlugin.php:1220-1227 installs its registration callback and :1781-1821 (maybe_register_service()) constructs/registers a service without a general exception boundary. Principle 10 calls for debug visibility and graceful production behaviour, while principles 4 and 5 favour WordPress hooks and injected collaborators.
Current proposal and maintainer questions
The concrete proposal is posted in the comments. Do not repeat the investigation or implement its recommendations as rulings. Choices still needing approval are: direct callbacks versus explicit guards versus an injected Hooks wrapper versus declarations; legacy activation/deactivation failure policy; explicit registering/registered/failed state and container insertion timing; production reporting and whether views participate; unchanged versus wrapped debug exceptions; staging the work; and exactly which resulting boundary unblocks #35.
For a wrapper, the proposal explicitly identifies callback identity/removal differences, strict scalar-call behaviour, by-reference rejection and an optional enforcement-rule migration. Those are compatibility questions, not approved implementation details. Scoped lifecycle/uninstall failures already propagate under #34 and stay outside any proposed containment unless the maintainer explicitly revises that ruling.
The old #27 recommendation was superseded by the view-only choice; it is prior art only. #34/#36/#27 are now closed/implemented, so references to their proposed future work are historical. Preserve their actual contracts when preparing the eventual implementation issue(s).
The optional registration-history/Query Monitor implementation from #38/#163 is now present. Any eventual boundary proposal must preserve its opt-in/disabled path and actual-decision history; that implementation does not approve the proposed production diagnostic action or view participation.
Asset loading now has its own implemented boundary in src/Infrastructure/ServiceBasedPlugin.php:2071-2105 (#37/#177): debug rethrows; production skips the failed service's remaining assets for that enqueue point and continues other services. Preserve that ruled behaviour alongside the view boundary. It does not settle the general Hooks proposal.
Scope
Investigate a potential injected Hooks abstraction and the general exception boundary. Deliver a concrete proposal, not implementation. Compare it with keeping direct WordPress hook registration and with capability-based declarations. Use the existing #27 proposal as prior work rather than treating it as approved.
Out of scope
- Implementing
Hooks, a generalErrorBoundary, new lifecycle interfaces, or changing callback registration. - Replacing the chosen interim view-only scope in views: degrade gracefully on creation and rendering failures in production #27 or duplicating completed views: production rendering does not degrade gracefully for every failure #30.
- Assuming approval for a diagnostic action, wrapping debug exceptions, changed container insertion timing, or the old proposal's other common implementation details.
Acceptance criteria
- Explain the benefit and cost of wrapping hooks, with sample service usage and injected collaborator wiring.
- Address callback identity/removal and
has_*interoperability, priorities/accepted arguments, zero-argument filter callbacks, and callbacks that add hooks dynamically. - Specify action/filter failure fallbacks, exception/debug behaviour, output-buffer/partial-output handling, and whether production diagnostic hooks are justified.
- Explain boundary placement and failure granularity for registration, pending/delayed services, activation/deactivation and infrastructure: lifecycle interfaces for multisite and uninstall #34's implemented lifecycle edges; identify partial-registration/dependency consequences.
- Assess compatibility, teaching cost, optional/default construction and architecture enforcement without weakening gates.
- Post options, trade-offs, recommendation and precise remaining maintainer questions before implementation. Any approved API/behaviour change must have its own compatibility ruling.
Verification
Review the written proposal against docs/design-principles.md and the current hook APIs and architecture rules. Include an implementation verification plan covering both debug modes, action/filter fallback, callable removal and lifecycle failures. Eventual code must pass composer test and composer lint; this spike has no implementation deliverable.
Impact on generated plugins
Investigation only. No API or runtime behaviour change. Potential wrapper adoption would affect callback identity and service dependencies; quantify those migrations in the proposal.
Priority p3: explicitly deferred exploration while #27 takes the smaller view-only approach.
Updated 2026-10-23: repaired the ServiceBasedPlugin citations against 8164f4a (after #154). The design proposal is posted in the comments; the issue waits on a maintainer ruling (needs: decision).
Updated 2026-10-23: Preserved the posted Hooks/boundary proposal and folded its exact unresolved policy/compatibility questions into the body; corrected moved registration anchors and reconciled implemented #34/#36/#27. Added breaking for proposed behavioural/API migrations, without approving them.
Updated 2026-10-23: Repaired registration anchors at main 61a9b00 and reconciled implemented #38/#163. The posted boundary/wrapper questions remain unapproved; existing opt-in history and disabled-path requirements must be preserved.
Updated 2026-10-24: Repaired registration anchors and reconciled the implemented asset boundary from #177. General Hooks/lifecycle/state/reporting choices still need the posted maintainer rulings; the existing scoped-lifecycle, view and asset policies remain authoritative. Reviewed origin/main 15cac4c2.
Activity
schlessera commentedon Oct 23, 2026
Picking this up. It is a spike, so the deliverable is a design proposal posted here, with no branch or implementation before a ruling (the branch would be
spike/143-hooks-boundaryif a prototype ever needed one).schlessera commentedon Oct 23, 2026
Design proposal: a
Hookscollaborator and the exception boundaryThis is checked against
origin/mainat8164f4a, which already includes #154 (delayed registration priority, #36). Every WordPress claim is checked against WordPress 6.9.4 core:wp-includes/class-wp-hook.php,wp-includes/plugin.php,wp-admin/includes/plugin.php,wp-includes/class-wp-fatal-error-handler.phpandwp-includes/class-wp-recovery-mode.php. A throwaway prototype that loads core's ownclass-wp-hook.phpandplugin.phpreproduced theWP_Hookbehaviour and the wrapper pitfalls below on PHP 7.4 and 8.3. Nothing was committed. An independent review of a first draft found several holes; this version fixes them.The body's citation
ServiceBasedPlugin.php:724-740has drifted:maybe_register_service()is now at:782-799. I have corrected it in the body.What is already decided
EmptyViewin production (src/Infrastructure/View/SimpleViewFactory.php:66-78,TemplatedViewFactory.php:97-108). A failing template throwsFailedToLoadViewin debug mode and renders''in production (SimpleView.php:135-154). That ruling approved none of the following, so they are all open here: a general callback wrapper, a capability-based hook API, a production diagnostic action, a debug-mode wrapper exception, a change to when services enter the container, and a per-service catch policy.add_action(), never through aHookswrapper.ServiceBasedPlugin.php:725-731,:747-762). The boundary below sits insidemaybe_register_service(), so either path is covered the same way.strict_types=1(hard rule).WordPress facts the design rests on (6.9.4)
_wp_filter_build_unique_id()(plugin.php:1000-1021) keys a string callback as itself, a closure or invokable object byspl_object_hash(),[ $object, 'm' ]as the object's hash plusm, and[ 'Class', 'm' ]asClass::m. Actions and filters share that key space.WP_Hook::add_filter()stores one entry per key and priority, and re-adding an existing entry replaces it in place,accepted_argsincluded (class-wp-hook.php:87-94).remove_filter()needs the same callback and the exact priority (:193-217).has_filter()gained a$priorityargument in 6.9 (:240-262). A wrapper is a different callable. After a wrapped add,has_filter( 'the_content', [ $service, 'prepend_post_header' ] )andremove_filter()with that callback both returnfalse(prototype).accepted_args = 0is called with no arguments, and anything else gets the arguments sliced to its count (class-wp-hook.php:338-344). A filter value is replaced by each callback's return value, including the return value of a zero-argument callback.do_action( 'x' )without arguments passes''(plugin.php:515-516).do_action_ref_array()andapply_filters_ref_array()can pass references.class-wp-hook.phpdoes not declarestrict_types, so WordPress calls callbacks in coercive mode: astringparameter accepts123. A call from a file withstrict_types=1is strict, throughcall_user_func_array()too (prototype, 7.4 and 8.3). Any wrapper insrc/therefore calls callbacks more strictly than WordPress does.try/finallyinWP_Hook. An exception that leaves a callback skips every later callback on that hook, other plugins' included. If something further out catches it, that hook's nesting level and$wp_current_filterare left behind for the rest of the request. In the prototype,doing_filter( 'x' )staystrueandcurrent_filter()keeps returningxafter the catch. Two consequences follow:do_action()orapply_filters();WP_Hook's private state, andarchitecture.noGlobalStaterules out patching$wp_current_filter.E_ERRORfatal, which PHP logs iflog_errorsis on.WP_Fatal_Error_Handlerthen usually shows the critical error screen (class-wp-fatal-error-handler.php:31-64: not while scraping an activation sandbox or in maintenance mode, and only if headers are not sent or in the admin). On single-site only (:54), recovery mode can email the administrator or pause the plugin. That needs the error to be attributable to a plugin file and to happen on a protected endpoint (class-wp-recovery-mode.php:168-200). An exception that is caught and swallowed loses all of that. Principle 10 rules outerror_log()as a replacement.activate_plugin()firesactivate_{$plugin}(wp-admin/includes/plugin.php:703) before it savesactive_plugins(:714), so an exception means the plugin is not activated.deactivate_plugins()firesdeactivate_{$plugin}inside its loop (:826) and saves the option only after the loop (:845). An exception there keeps this plugin active, and also every other plugin in the same bulk action.Where exceptions leave the plugin today
plugins_loadedregister()ServiceBasedPlugin.php:307-314→register_services():329(injector configuration:355,servicesfilter:391, normalization:397, scheduling):749-759→maybe_register_service():782-799:512-514→register_pending_services():482, which asksis_needed()(:555) and can throwFailedToResolveDependencies(:562,:649,:670)basic-scaffold.php:119-131→activate():195/deactivate():217, both of which callregister_services()firstSampleBackendService.php:76,SampleLoopService.php:113Part 1: the policy (the same in every option)
One small infrastructure class,
ExceptionBoundary, which isfinal. It takes the name of the diagnostic action and an optional?DebugModethat falls back toWordPressDebugMode(principle 3). It has one method,contain( Throwable $failure, FailureSite $site ): void:$failureunchanged (question 5).FailureSiteis a small value object that says where the failure happened: a service ID, or a hook, a priority and a description of the callback. That follows principle 8 instead of passing a bare string.It catches
Throwable, as the view system does. The most likely production failure is aTypeErrorcaused by loosely typed WordPress data (principle 9), and that is anError, not anException. Fatal errors such as memory exhaustion or a timeout cannot be caught at all.One instance per plugin.
ServiceBasedPlugingets an optional constructor parameter for the boundary, placed after the runner and injector factory that #34 adds. Without one, it builds the default withstatic::HOOK_PREFIX . 'failure_contained'. It then delegatesExceptionBoundaryto that instance in the injector, exactly as it already does forInjector(:365-368). So registration and service callbacks share one policy, and a customDebugModereaches both.Fallbacks. A filter returns its first argument as it received it (
nullif there was none). An action does nothing. A filter registered withaccepted_args = 0still needs that first argument, so its wrapper is registered with at least one argument and calls the callback with none (prototype: a throwing zero-argument filter returns'original').Part 2: the infrastructure's own edges (independent of Part 3)
Placement: inside the methods, not around the callbacks.
register()keeps adding[ $this, 'register_services' ], so its identity, and anyremove_action()against it, stays as it is. The catches go insideregister_services(),register_pending_services()andmaybe_register_service().The plugin's own filters stay outside the
try. A listener that throws onservices,bindings,arguments,shared_instancesordelegationsis another plugin's code. Catching it would leave that filter's state wrong (fact 4). Soapply_filters()runs outside thetry, and such a failure propagates as it does today. The boundary contains what the plugin itself does with the result: validating, configuring and scheduling it.Failure scope, for every call into a service class:
:355,:397:562,:649,:670,:1253get_dependencies(),get_registration_action(),get_registration_priority():551,:673,:701,:738-743,:1253is_needed(), on both paths:555(pending),:789(scheduled):793register():797FailedToResolveDependencies. That goes for the pending path too.Registration state, not container membership. Today the service goes into the container (
:794) beforeregister()runs (:797), and container membership is the only guard against registering twice (:784-786). Ifregister()throws part-way, the service stays in the container, so its dependents count it as registered and register against a half-registered service. Moving the insertion afterregister()alone would open a re-entrancy hole: aregister()that causes its own registration action to fire again would register the service a second time. So each service gets an explicit state: registering (set before any of its code runs), registered and failed. A service enters the container only once it is registered (question 3). Hooks that a failedregister()had already added stay attached, because WordPress has no transaction to roll back. That gets documented.Covered without extra work: the delayed and resumption closures, because they go through
maybe_register_service()andregister_pending_services(). Not covered: lazy services (those that are notRegisterable) are built when something retrieves them, and whatever retrieves one is responsible for its failure.Lifecycle edges propagate in both modes (question 2), the same policy #34 approved for the scoped edges. Under #34's precedence ruling, one event reaches a given service through either the legacy interface or a scoped one. Two failure policies for one event would make the outcome depend on which interface the service happens to implement.
activate()anddeactivate()let their services' exceptions through. For activation, fact 6 makes that the right outcome: the plugin stays inactive and the administrator sees the error. For deactivation the cost is real: a throwingdeactivate()keeps the plugin active, together with the rest of a bulk deactivation. The ways out are fixing the cause, recovery mode (single-site only), or removing the plugin directory.activate()ordeactivate()callsregister_services()(:196,:218), registration failures propagate as well.register_services()bails out on its second call (:341-345). So if registration failed and was contained atplugins_loaded, a laterdeactivate()in the same request would run over an incomplete map without noticing. Instead, the plugin keeps the contained failure, andactivate()anddeactivate()rethrow it before dispatching anything.basic-scaffold.phpstay one-line delegations. The text that currently says the bridge is where exceptions get caught (docs/design-principles.md:267-272,docs/patterns.md:505-510) changes to say that lifecycle exceptions propagate on purpose.Part 3: services' own callbacks
A. Keep direct WordPress hooks, with no general boundary (today's code). Services call
\add_action()directly, and only view failures are contained.has_action(),remove_action()and WordPress's type coercion all work as usual.B. Direct hooks, plus an explicit guard inside each callback. Callback identity is untouched, and the fallback is visible where it applies:
has_*,remove_*, priorities,accepted_argsand coercion of the callback's own parameters all stay pure WordPress.architecture.dependencyDirection), so the guard needs an interface of its own as well.C. An injected
Hookscollaborator (recommended). It wraps each callback in the boundary. It is deliberately narrower than the WordPress API, not a one-to-one mirror:The differences from WordPress, on purpose:
add_*()returns nothing, because WordPress always returnstrue.has_*()without a callback does not touch identity, so services keep calling\has_action( 'hook' )directly.callable, because the wrapper has to call them. A speculative removal of a non-callable just returnsfalseon the WordPress side and gives the plugin no reason to support it.The sample service changes in two places, and the callback stays as it is:
The composition root binds
Hooks::class => GuardedHooks::classand sharesGuardedHooks. Sharing is required, not an optimization:remove_*andhas_*only find a wrapper through the same instance that added it.GuardedHooksreceives the plugin'sExceptionBoundarythrough the injector delegation from Part 1. The infrastructure's own callbacks and #34's lifecycle edges keep calling WordPress directly.What the implementation has to get right:
GuardedHookskeys its wrappers by (hook, priority, callback identity), built as_wp_filter_build_unique_id()builds them, so actions and filters share the key space as they do in WordPress. Each wrapper is a small invokable object that holds the callback, the kind (action or filter) andaccepted_args. Re-adding the same callback updates those values and calls WordPress again with the same wrapper. WordPress then replaces the entry in place, keeping its position and updatingaccepted_args(fact 1). Without that reuse, every call would add a fresh wrapper and a second entry, andarchitecture.compositionRootContractswould reportregister()as not idempotent. That existing gate therefore enforces the reuse.has_*()checks the wrappers in ascending priority, so it returns the lowest priority, as WordPress does, and not the first one added.has_filter()orremove_filter()called with the original callback no longer finds it. Principle 13 already keeps service instances out of reach of other code, so outside code can only have relied on this for string or static callbacks. Tests that asserthas_action( …, [ $service, 'method' ] )need to change; the two in the scaffold aretests/php/Integration/SampleBackendServiceTest.php:66andSampleLoopServiceTest.php:51.max( 1, $accepted_args )and hands the callback exactly$accepted_argsarguments.do_action_ref_array( 'x', [ &$list ] )left$listempty. A wrapper that takes them by reference emits a warning on every ordinary call, and a wrapper that switches by reflection still gets mixed parameter lists wrong. Core passes references almost only for objects, which need no reference at all. SoGuardedHooksrejects a callback with a by-reference parameter, with anInvalidArgumentnaming it. During registration, that is a failure of that one service. The pattern says to take the object, or to return the value from a filter.src/calls the callback in strict mode, so astring $contentparameter given123fails, where WordPress would have converted it. In production that failure is contained and the filter returns its input. In debug mode it is aTypeError. That is in the spirit of principle 9, but it is a behaviour change for existing callbacks, and it needs its own yes (question 1). The alternative, calling from a file withoutstrict_types, breaks a hard rule.add_action()would fall back tonull. The docs say so.architecture.hooksInLifecycleMethodsalready restricts adding hooks to the lifecycle methods, and C applies that rule toHookscalls as well.Fits: principle 10 for every service callback, with no
try/catchin services (the core idea); principles 3 and 5 (injected and shared, with a default); principle 4 (a thin layer, not an event system); principle 14, since the sample reads almost like plain WordPress. Costs: one more constructor parameter per hooking service, the identity caveat, strict typing, no by-reference parameters, and a little bookkeeping per added callback.D. A capability declaration. For example
HasHooks::get_hooks(): arrayreturnsHookvalue objects, and the plugin adds them, wrapped.register(). Hooks that are conditional or computed at runtime are awkward to declare. It has the larger public surface (an interface and a value object), and it has the same identity, typing and reference costs as C. For teaching material, two ways of doing the most common thing is the largest cost of all.has_*/remove_*with the original callbackHooksHooks,GuardedHooksadd_*callsregister()Part 4: output and partial output
The boundary does not buffer output. Buffering every action callback would break callbacks that open a buffer on purpose and leave it open: whole-page post-processing started at
template_redirectis the common case, and streaming output and early headers are others.architecture.outputOnlyThroughViewsalready means a service only prints the direct result of rendering a view, and each view buffers its own template and returns all of its output or none of it (#30, #150). So the worst partial output is the earlierechostatements of a callback that fails half-way. The patterns entry teaches oneechoper callback, of one parent view that renders its partials. A partial that fails then leaves only its own place empty, as it already does today.Part 5: is a production diagnostic hook justified?
Yes, I think so. Today a production failure usually shows up in PHP's error log and in WordPress's fatal error handling (fact 5). Containing the failure removes that. Without a replacement, a contained failure leaves no trace at all, which makes the site less observable than it is today. A prefixed action,
mwpd.basic_scaffold.failure_contained, passing theThrowableand theFailureSite, is the WordPress-native way (principle 4) for a logging plugin or Query Monitor (#38) to pick it up. It is public API under principle 13, built fromHOOK_PREFIXand checked byarchitecture.prefixedNames.A listener that throws is another plugin's bug. The boundary does not catch it: catching it would leave the action's own state wrong (fact 4), and there is no way to report a failing reporter anyway. The failure propagates as an ordinary uncaught exception would today. A re-entrancy guard keeps a failure inside a listener from reporting itself again. The alternative is an injected
FailureReporterwith a no-op default. It is easier to replace in tests, but only reachable from the plugin's own composition root. I prefer the action.Compatibility, teaching cost and enforcement
WP_DEBUGis undefined, registration exceptions no longer propagate. Tests that expect them have to switch debug mode on. Intests/php/Unit/ServiceBasedPluginTest.php, that is 12 of its 13expectException()cases; the remaining one (:787-793) is an injector failure after registration and is unaffected. A generated plugin with its own such tests needs the same change. The optional constructor parameter adds API, but it changes the constructor's line intests/php/Architecture/infrastructure-api.txt, which goes through the snapshot's review.breaking, for the production behaviour.\add_*call becomes$this->hooks->add_*. Callbacks with by-reference parameters are rewritten. Tests that check hooks against the original callback useHooksinstead (two in the scaffold). The composition root sharesGuardedHooksand bindsHooksto it. Other code that removed one of the plugin's string or static callbacks no longer can. If the rule below ships with it, every direct hook call in a generated plugin's subsystems failscomposer lintuntil it is migrated, so that isbreakingtoo.architecture.hooksThroughBoundary) reportsadd_action(),add_filter(),remove_*(), andhas_*()with a callback, when called directly in feature subsystems. Its message says to injectHooksinstead. The infrastructure and the composition root stay exempt;noHooksInConstructorandhooksInLifecycleMethodsalso cover calls on aHooks-typed value;prefixedNameschecksHooks::add_action()calls forwp_ajax_actions the way it checksadd_action()today. Otherwise moving AJAX handlers toHookswould quietly drop that check;compositionRootContractsalready checks idempotence by callback identity, which catches aGuardedHooksthat does not reuse its wrappers;Hooksdoes not show up inhas_action()with the original callback, why the callback gets strict types, and why by-reference parameters are out. In return, principle 7's table gets a row ("one failing callback takes the whole page down" → "Hookscontains it"), and principle 10 can drop its "other callbacks do not yet" caveat. A new patterns entry, "I need a hook callback that fails safely", explains it.Verification plan for the implementation
Brain Monkey does not run callbacks. So the unit tests capture the wrapper that
add_filter()/add_action()receives and call it the wayWP_Hookdoes, with the arguments sliced. One integration test loads WordPress's realWP_Hookbehaviour through a dev-only fixture, so that identity, in-place replacement and nesting are checked against core and not against a stand-in. Whether that fixture is worth adding is a detail for the implementation brief.Hooks, with debug mode on and off: a throwing action and a throwing filter. Debug mode rethrows the same instance. Production returns the first argument as received for a filter and nothing for an action, and fires the action once with the rightFailureSite.accepted_argsslicing. A callback with a by-reference parameter is rejected. A coercible scalar (123for astringparameter) fails in strict mode and is contained in production.accepted_argsupdates the entry in place;remove_*andhas_*throughHookswork at the right priority;has_*returns the lowest priority; a different priority is a different entry.is_needed()(on the scheduled path and on the pending path), constructor orregister()throws, next to an unrelated service. Production: the unrelated service registers, the failed one is not in the container and is not retried, its dependents are skipped withoutFailedToResolveDependencies, and the action fires. Debug mode: the original exception propagates. Then the whole-run cases: an invalidservicesfilter result, a throwingget_dependencies(), a cycle, a delayed service failing at its action, a resumption failing. A throwing listener on theservicesfilter propagates in both modes.register()that fires its own registration action again registers the service once.plugins_loadedmakes a laterdeactivate()on the same instance throw it. infrastructure: lifecycle interfaces for multisite and uninstall #34's lifecycle tests stay unchanged.composer teston PHP 7.4 and 8.3, andcomposer linton 8.3, as in CI.Questions for the ruling
breaking), or does C start as opt-in, with the rule following later?register()has returned, with an explicit registering/registered/failed state guarding against re-entry?failure_containedaction? And should the view system (Degrade view creation and rendering failures in production #150) fire it too? That would be a separate, small behaviour change to an approved policy, so it needs its own yes or no.Recommendation (separate from approval)
breaking: Part 1 and Part 2. That meansExceptionBoundaryandFailureSiteshared through the injector, containment per service on the request path with the scope table above, explicit registration state, thefailure_containedaction, rethrowing unchanged in debug mode, and propagation for every lifecycle edge, including a failure that was contained earlier in the request. This is the highest-value step: today a single broken service atplugins_loadedtakes every page of the site down in production. It changes nothing about how services add hooks.prefixedNamesextension shipping at the same time. The scaffold should then teach one way to add a hook. C is the option with the most fine print (identity, strict types, references). If plain-WordPress readability matters more to you than containing callback failures, A is defensible: the view work already covers the failure the samples are most likely to hit.register()had already added.schlessera commentedon Oct 23, 2026
Handing off: this issue now waits on a maintainer ruling on the seven questions in the proposal above. To resume, record the decision as a
**Decision (maintainer, <date>):**comment and fold it into the body. If staging is approved (question 6), file stage 1 and stage 2 as their own issues with their own compatibility rulings, and point #35's blocker at the stage 1 issue. Then removeneeds: decisionhere. I have released my assignment.schlessera commentedon Oct 23, 2026
Triage (2026-10-23): Preserved the posted Hooks/boundary proposal and folded its exact unresolved policy/compatibility questions into the body; corrected moved registration anchors and reconciled implemented #34/#36/#27. Added breaking for proposed behavioural/API migrations, without approving them.
schlessera commentedon Oct 23, 2026
Triage (2026-10-23): Repaired registration anchors at main 61a9b00 and reconciled implemented #38/#163. The posted boundary/wrapper questions remain unapproved; existing opt-in history and disabled-path requirements must be preserved.
schlessera commentedon Oct 24, 2026
Triage (2026-10-24): Repaired registration anchors and reconciled the implemented asset boundary from #177. General Hooks/lifecycle/state/reporting choices still need the posted maintainer rulings; the existing scoped-lifecycle, view and asset policies remain authoritative.