pi-daddy 0.27.4 → 0.32.0

package/extensions/session.ts

@@ -13,16 +13,16 @@
  * module reads them **through this object**, live, rather than capturing a copy at load time; capturing a
  * copy of `ownGrant` before observation is exactly how a stale upper bound would become an enforced one.
  */
-
-import { parseInherited, type InheritableApproval } from "../src/approval.ts";
-import type { ApprovalBinding } from "../src/correlation.ts";
-import { createApprovalGateProvider } from "../src/approval-prompt.ts";
-import { makeCatalog, skillPathsFromCatalog, type Catalog } from "../src/catalog.ts";
-import type { SkillDefinition } from "../src/definitions.ts";
-import { DELEGATE_CAPABILITY, type DelegationContext } from "../src/delegate.ts";
-import { budgetFromEnv } from "../src/fanout.ts";
-import { chooseExecutor, ENV_HERDR, type ExecutorChoice } from "../src/executor.ts";
-import { WILDCARD } from "../src/pi-tools.ts";
+import { randomUUID } from "node:crypto";
+import { parseInherited, type InheritableApproval } from "../src/kernel/approval.ts";
+import type { ApprovalBinding } from "../src/kernel/correlation.ts";
+import { createApprovalGateProvider } from "../src/governance/approval-prompt.ts";
+import { makeCatalog, skillPathsFromCatalog, type Catalog } from "../src/kernel/catalog.ts";
+import type { SkillDefinition } from "../src/kernel/definitions.ts";
+import { DELEGATE_CAPABILITY, type DelegationContext } from "../src/kernel/delegate.ts";
+import { budgetFromEnv } from "../src/kernel/fanout.ts";
+import { chooseExecutor, ENV_HERDR, type ExecutorChoice } from "../src/executors/executor.ts";
+import { WILDCARD } from "../src/kernel/pi-tools.ts";
 import {
   childEnv,
   depthConfig,
@@ -39,17 +39,16 @@ import {
   ENV_PARENT_ID,
   GRANT_ENV_KEYS,
   parseList,
-} from "../src/propagation.ts";
-import type { Capability } from "../src/resolve.ts";
-import { loadDefinitions } from "../src/definitions.ts";
-import { buildCatalog } from "../src/catalog.ts";
-import { ENV_WORKSPACE_REGISTRY } from "../src/workspace.ts";
-import type { GrantStoreRefusalReason } from "../src/grant-store.ts";
+} from "../src/kernel/propagation.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
+import { loadDefinitions } from "../src/kernel/definitions.ts";
+import { buildCatalog } from "../src/kernel/catalog.ts";
+import { ENV_WORKSPACE_REGISTRY } from "../src/kernel/workspace.ts";
+import type { GrantStoreRefusalReason } from "../src/governance/grant-store.ts";
 import { republishable } from "./approvals.ts";
 import { storedGrantSessionState } from "./stored-grant-session.ts";
-import { nativeSessionRootFromEnv, type NativeSessionHost } from "../src/native-session-target.ts";
-import { ENV_ALLOW_UNRESOLVED_MODELS } from "../src/model-preflight.ts";
-import type { DeclaredWorkState } from "../src/work-command.ts";
+import { nativeSessionRootFromEnv, type NativeSessionHost } from "../src/executors/native-session-target.ts";
+import { ENV_ALLOW_UNRESOLVED_MODELS } from "../src/kernel/model-preflight.ts";
 import { beginExtensionLifecycle, rememberChildPublication, type ReloadLifecycle } from "./reload-environment.ts";
 import { reconcileSessionEnvironment } from "./session-environment.ts";
 /**
@@ -63,37 +62,49 @@ import { reconcileSessionEnvironment } from "./session-environment.ts";
  * `/grants`. Both executors still enforce the identical grant: the plan is the same, only the place it runs
  * differs.
  *
- * The table itself is a pure function in `../src/executor.ts`; re-exported here because this is where every
- * other `PI_GRANTS_*` name lives and a reader looking for it will look here.
+ * The table itself is a pure function in `src/executors/executor.ts`; re-exported here because this is where every
+ * other `PI_DADDY_*` name lives and a reader looking for it will look here.
  */
-export { ENV_HERDR } from "../src/executor.ts";
+export { ENV_HERDR } from "../src/executors/executor.ts";
 /**
  * herdr workspace for spawned panes — re-exported from where it is actually READ.
  *
  * It was declared here and read nowhere: `resolveWorkspace` reads the string literal, so the constant and the
  * literal could drift with nothing binding them. Re-exporting the single definition keeps this the place a reader
- * looks for a `PI_GRANTS_*` name without letting two spellings exist.
+ * looks for a `PI_DADDY_*` name without letting two spellings exist.
  *
  * Omitting the variable no longer means "let herdr choose": it falls back to the parent's own
  * `HERDR_WORKSPACE_ID`, because a child in a different workspace from the session that spawned it makes switching
  * to it a workspace hop (ADR-0032). This name is the operator's explicit override.
  */
-export { ENV_HERDR_WORKSPACE } from "../src/herdr-cli.ts";
-/** Keep each child's pane after it finishes, for inspection. Off by default: fan-out would flood it. */
-export const ENV_HERDR_KEEP_PANE = "PI_GRANTS_HERDR_KEEP_PANE";
+export { ENV_HERDR_WORKSPACE } from "../src/executors/herdr-cli.ts";
+import {
+  ENV_ACTIVITY_PARENT_TASK,
+  ENV_ACTIVITY_PATH,
+  ENV_ACTIVITY_ROOT,
+  ENV_ACTIVITY_TASK,
+} from "../src/products/activity-timeline.ts";
+import { ENV_HERDR_KEEP_PANE, ENV_GOVERNANCE } from "../src/kernel/env-names.ts";
+export { ENV_HERDR_KEEP_PANE, ENV_GOVERNANCE } from "../src/kernel/env-names.ts";
+import { adoptLegacyEnvironment } from "../src/kernel/env-names.ts";
 
-export interface VariantRunAccounting {runId:string;primaryExecutionId:string;shadowExecutionIds:string[];state:"running"|"settled";outcomes:null|{executionId:string;role:"primary"|"shadow";ok:boolean;reason:string|null}[]}
+/** The activity timeline's per-child observation identity, handed to the kernel through `childEnv` (ADR-0076). */
+export function activityChildEnv(activity: { rootId: string; path: string; taskId?: string } | undefined) {
+  return (child: { childExecutionId?: string }): Readonly<Record<string, string>> =>
+    activity?.taskId && child.childExecutionId
+      ? {
+          [ENV_ACTIVITY_PATH]: activity.path,
+          [ENV_ACTIVITY_ROOT]: activity.rootId,
+          [ENV_ACTIVITY_TASK]: child.childExecutionId,
+          [ENV_ACTIVITY_PARENT_TASK]: activity.taskId,
+        }
+      : {};
+}
+/** Keep each child's pane after it finishes, for inspection. Off by default: fan-out would flood it. */
 export interface GrantsSession extends NativeSessionHost {
-  /**
-   * False when neither `PI_GRANTS_GRANT` nor a stored grant applies: the session holds the wildcard and
-   * nothing is governed.
-   *
-   * **Mutable, because `/grants init` makes an ungoverned session governed mid-run.** The first version of
-   * ADR-0030 left this readonly on the reasoning that a store is read at creation and `init` only runs where
-   * one exists — which is false for the first `init` in a directory, the most common case there is. The
-   * session then bounded every spawn by the new grant while `/grants` reported "inactive", so the status
-   * line contradicted the enforcer. Found by running it.
-   */
+  /** Legacy PI_GRANTS_* names adopted at construction (ADR-0076 PR 3b); the session-start warning names them. */
+  readonly adoptedLegacyEnv: readonly string[];
+  /** False only for the explicit PI_DADDY_GOVERNANCE opt-out; otherwise roots are observed-bound. */
   governed: boolean;
   /** The upper bound handed down by the delegator, before this session's own tools are observed. */
   inherited: Capability[];
@@ -133,9 +144,11 @@ export interface GrantsSession extends NativeSessionHost {
   readonly modelResolutionCache: Map<string, boolean>;
   /** Path to this extension, so a child granted `tool:delegate` can delegate in turn. */
   readonly extensionPath?: string;
-  declaredWork?: DeclaredWorkState; // Explicit operator selection; absence leaves execution visibly unbound.
-  /** Primary-return fan-outs retained by this original session; bounded and human-readable via /grants variants. */
-  readonly variantRuns: Map<string, VariantRunAccounting>;
+  /** Hook-only observer path for leaf children; it exposes no tools. */
+  readonly observerExtensionPath?: string;
+  /** Stable root identity plus current turn, used only to join local activity facts. */
+  activityRootId: string;
+  activity?: { rootId: string; path: string; taskId?: string };
   /** Root identity keyed to ctx.sessionManager once session_start supplies it. */
   reloadLifecycle: ReloadLifecycle;
   /** Approval keys approved for this session. In memory only — this dies with the process. */
@@ -171,7 +184,6 @@ export interface GrantsSession extends NativeSessionHost {
    * but non-deterministically: the same delegation succeeded or failed on timing alone.
    */
   catalogReady: Promise<Catalog>;
-
   /**
    * The one place a delegation context is built — and therefore the one place each field is spelled.
    *
@@ -185,7 +197,6 @@ export interface GrantsSession extends NativeSessionHost {
    * diagnostic that disagrees with enforcement is not expressible.
    */
   delegationContext(approved?: InheritableApproval[]): Promise<DelegationContext>;
-
   /**
    * Publish what children inherit. Written once at session start, and republished whenever this
    * session's own approvals change (see `obtainApprovals`) — never once per spawn. That distinction is
@@ -215,7 +226,6 @@ export interface GrantsSession extends NativeSessionHost {
   adoptGrant(grant: Capability[], projectLedger?: string): void;
   reconcileEnvironment(environment: NodeJS.ProcessEnv, lifecycle: ReloadLifecycle): void;
 }
-
 /**
  * Parse the environment once and build the session every other module reads through.
  *
@@ -244,30 +254,30 @@ export async function loadProjectDefinitions(session: GrantsSession, cwd: string
   });
   session.catalog = await session.catalogReady;
 }
-
-export function createGrantsSession(extensionPath: string | undefined, lifecycle?: ReloadLifecycle): GrantsSession {
+export function createGrantsSession(
+  extensionPath: string | undefined,
+  lifecycle?: ReloadLifecycle,
+  observerExtensionPath?: string,
+): GrantsSession {
+  // ADR-0076 PR 3b: legacy PI_GRANTS_* names are adopted BEFORE the first environment read and before the
+  // reload snapshot, or an operator on the old names would get an ungoverned wildcard root (review finding).
+  const adoptedLegacyEnv = adoptLegacyEnvironment(process.env);
   const started = lifecycle ? undefined : beginExtensionLifecycle();
   const activeLifecycle = lifecycle ?? started!.lifecycle;
   const environment = lifecycle ? process.env : started!.environment;
-  // Governance is opt-in: with PI_GRANTS_GRANT unset AND no stored grant for this directory, the session
-  // holds the wildcard and nothing is blocked. This extension must never silently tighten a normal
-  // workflow.
-  //
-  // **Two sources, and the environment always wins** (ADR-0030). The variable is how a CHILD is governed
-  // and how CI is configured, so a store that could override it would let a directory quietly widen or
-  // narrow a child its parent had already bounded. The store is consulted only when the variable is absent,
-  // which is exactly the case it was added for: a human at a terminal who ran `/grants init` here.
-  //
-  // `process.cwd()` rather than `ctx.cwd`, because this runs in the extension factory — before any hook,
-  // and therefore before `ctx` exists. That ordering is forced by S-5: whether `delegate` is registered at
-  // all is decided here, and a grant arriving later could not inform it. `session_start` re-checks the two
-  // against each other and says so if they differ, which is the only case this can get wrong.
+  const activityRootId = activeLifecycle.activityRootId ?? randomUUID();
+  activeLifecycle.activityRootId = activityRootId;
+  // Local governance is on unless PI_DADDY_GOVERNANCE opts out; explicit inherited grants still win.
+  // The factory precedes ctx, so its cwd/store identity is reconciled at session_start.
   const grantRaw = environment[ENV_GRANT];
   const storeCwd = process.cwd();
   // One root-only store read supplies both decisions made by `/grants init`. A child always has ENV_GRANT,
   // so it cannot activate a ledger merely because its routed cwd happens to have a v2 store (ADR-0037).
   const storedState = storedGrantSessionState(grantRaw, storeCwd);
-  const { governed, inherited, refusal: grantStoreRefusal } = storedState;
+  const governanceOff = environment[ENV_GOVERNANCE]?.trim() === "off" || environment[ENV_GOVERNANCE]?.trim() === "0";
+  const governed = governanceOff ? false : true;
+  const inherited = governanceOff ? storedState.inherited : storedState.governed ? storedState.inherited : [WILDCARD];
+  const grantStoreRefusal = storedState.refusal;
   const ledgerRaw = environment[ENV_LEDGER];
   // Capture provenance before publishChildEnv writes this session's derived default into process.env. A later
   // `/grants init` for ctx.cwd must not mistake our own publication for an operator override.
@@ -278,18 +288,18 @@ export function createGrantsSession(extensionPath: string | undefined, lifecycle
   const bounds = depthConfig(environment[ENV_DEPTH], environment[ENV_MAX_DEPTH]);
   const { depth, maxDepth } = bounds;
   const emptyCatalog = makeCatalog([]);
-
   const session: GrantsSession = {
+    adoptedLegacyEnv,
     governed,
     inherited,
     depth,
     maxDepth,
     malformedBounds: bounds.malformed,
     // ADR-0012: `bash` is gated by DEFAULT — but only in a governed session. An ungoverned one
-    // (no PI_GRANTS_GRANT) still blocks nothing, so "governance is opt-in" holds exactly where it always
+    // (no PI_DADDY_GRANT) still blocks nothing, so "governance is opt-in" holds exactly where it always
     // did. Inside a session the operator already chose to govern, handing a child `bash` hands it an
     // ungoverned-descendant escape hatch, and doing that silently is what changes here.
-    // `PI_GRANTS_GATED=""` turns the default off; absent and empty are deliberately distinguishable.
+    // `PI_DADDY_GATED=""` turns the default off; absent and empty are deliberately distinguishable.
     gated: governed ? gatedFromEnv(environment[ENV_GATED]) : parseList(environment[ENV_GATED]),
     // Presence wins, including an explicitly empty value for a one-run opt-out. The store is eligible only
     // when ENV_GRANT was absent above, preserving the environment as the child's single authority channel.
@@ -319,7 +329,8 @@ export function createGrantsSession(extensionPath: string | undefined, lifecycle
     nativeSessionRoot: nativeSessionRootFromEnv(process.env),
     modelResolutionCache: new Map<string, boolean>(),
     extensionPath,
-    variantRuns: new Map(),
+    observerExtensionPath,
+    activityRootId,
     reloadLifecycle: activeLifecycle,
     sessionApprovals: new Set<string>(),
     sessionApprovalBindings: new Map<string, ApprovalBinding>(),
@@ -339,6 +350,8 @@ export function createGrantsSession(extensionPath: string | undefined, lifecycle
       gated: session.gated,
       ledgerPath: session.ledgerPath,
       extensionPath: session.extensionPath,
+      observerExtensionPath: session.observerExtensionPath,
+      childEnv: activityChildEnv(session.activity),
       catalog: await session.catalogReady,
       // R-32: where each granted skill lives, so `planSpawn` can pass `--skill` for those and only those.
       // Derived from the catalog's own `source`, so it cannot drift from what was discovered.
@@ -355,10 +368,8 @@ export function createGrantsSession(extensionPath: string | undefined, lifecycle
       interactive: session.executor.kind === "herdr",
       ...(approved ? { approved } : {}),
     }),
-
     storeCwd,
     ...(grantStoreRefusal ? { grantStoreRefusal } : {}),
-
     adoptGrant: (grant: Capability[], projectLedger?: string) => {
       // Governed too, not just bounded. A session that starts with no grant and then runs `/grants init` is
       // governed from that moment: every spawn is bounded by what was just stored. Leaving this false made
@@ -373,7 +384,6 @@ export function createGrantsSession(extensionPath: string | undefined, lifecycle
       }
       session.publishChildEnv();
     },
-
     reconcileEnvironment: (environment, lifecycle) => reconcileSessionEnvironment(session, environment, lifecycle),
     publishChildEnv: () => {
       const env = childEnv({

package/extensions/spawn-summary.ts

@@ -11,7 +11,7 @@
  * **Decided by the real planner, and — since a reviewer caught it — no longer re-classified afterwards.**
  * The first version read two fields of `plan.result` and invented a category from them, which is the very
  * thing this header claimed to have made inexpressible: `planDelegation` has six refusals that leave both
- * fields empty, so a session at its depth limit, or one with a malformed `PI_GRANTS_MAX_DEPTH`, was told its
+ * fields empty, so a session at its depth limit, or one with a malformed `PI_DADDY_MAX_DEPTH`, was told its
  * **files** were written wrong while `/grants` in the same session said "delegation is disabled (maxDepth
  * 0)". That is R-28's shape inside the fix for R-28's shape. The planner's own `reason` is now printed for
  * anything the two designated signals do not explain.
@@ -23,12 +23,12 @@
  * and `/grants` run after any request is the settled answer.
  */
 
-import type { SkillDefinition } from "../src/definitions.ts";
+import type { SkillDefinition } from "../src/kernel/definitions.ts";
 import type { GatedPlan } from "./run-delegation.ts";
 
 /** Why a definition is not spawnable right now. Three causes, three different fixes. */
 export type WithheldReason =
-  /** The grant lacks `agent:<name>`, or lacks a tool the ceiling declares. Fix: widen `PI_GRANTS_GRANT`. */
+  /** The grant lacks `agent:<name>`, or lacks a tool the ceiling declares. Fix: widen `PI_DADDY_GRANT`. */
   | "capability"
   /** Everything is held, but a gated capability needs a human yes first. Fix: spawn it and answer. */
   | "approval"
@@ -108,7 +108,7 @@ export async function summariseSpawnable(
       notChecked: 0,
       sessionBlocked:
         `this session holds no tool:delegate, so it has no delegate tool at all — nothing can be spawned, ` +
-        `whatever any definition declares. Add tool:delegate to PI_GRANTS_GRANT to make this session a ` +
+        `whatever any definition declares. Add tool:delegate to PI_DADDY_GRANT to make this session a ` +
         `delegator rather than a leaf.`,
     };
   }
@@ -120,7 +120,7 @@ export async function summariseSpawnable(
       sessionBlocked:
         session.maxDepth <= 0
           ? `spawning is disabled for this session (max depth ${session.maxDepth}), so no definition can ` +
-            `run whatever its file says. If you did not set PI_GRANTS_MAX_DEPTH to 0, check the warning ` +
+            `run whatever its file says. If you did not set PI_DADDY_MAX_DEPTH to 0, check the warning ` +
             `above: a malformed value disables spawning deliberately.`
           : `this session is at its depth limit (${session.depth} of ${session.maxDepth}), so it may not ` +
             `spawn — a definition refused here is not a problem with its file.`,

package/extensions/stored-grant-session.ts

@@ -4,10 +4,10 @@ import {
   projectLedgerPath,
   type GrantStoreRefusalReason,
   type StoredGrant,
-} from "../src/grant-store.ts";
-import { WILDCARD } from "../src/pi-tools.ts";
-import { parseList } from "../src/propagation.ts";
-import type { Capability } from "../src/resolve.ts";
+} from "../src/governance/grant-store.ts";
+import { WILDCARD } from "../src/kernel/pi-tools.ts";
+import { parseList } from "../src/kernel/propagation.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
 
 export interface StoredGrantSessionState {
   stored?: StoredGrant;
@@ -26,7 +26,7 @@ export function storedGrantSessionState(grantRaw: string | undefined, cwd: strin
     ...(stored ? { stored } : {}),
     ...(refusal ? { refusal } : {}),
     governed: grantRaw !== undefined || stored !== undefined || refusal !== undefined,
-    inherited: grantRaw !== undefined ? parseList(grantRaw) : stored?.grant ?? (refusal ? [] : [WILDCARD]),
+    inherited: grantRaw !== undefined ? parseList(grantRaw) : (stored?.grant ?? (refusal ? [] : [WILDCARD])),
     // Invalid state authorises only a refusal line at this conventional path; no child can start from it.
     defaultLedger: stored?.projectLedger || refusal ? projectLedgerPath(cwd) : undefined,
   };

package/extensions/tripwire.ts

@@ -39,6 +39,6 @@ export function tripwireReason(toolName: string): string {
     `hold whatever that extension decided, with no grant, no depth bound and no ledger entry. ` +
     `Use \`delegate\` for a single sub-agent, or \`delegate_all\` to run several CONCURRENTLY — that is the ` +
     `governed equivalent of a parallel or chained spawn, and it is what to reach for when independent tasks ` +
-    `can proceed at the same time. If you meant to run ungoverned, unset PI_GRANTS_GRANT.`
+    `can proceed at the same time. If you meant to run ungoverned, unset PI_DADDY_GRANT.`
   );
 }

package/extensions/workspace-runtime.ts

@@ -1,22 +1,21 @@
-import type { CorrelationMetadata } from "../src/correlation.ts";
-import type { Capability } from "../src/resolve.ts";
+import type { CorrelationMetadata } from "../src/kernel/correlation.ts";
+import type { Capability } from "../src/kernel/resolve.ts";
+import { appendLedgerEvent, buildWorkspaceLeaseEvent } from "../src/governance/ledger.ts";
+import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/kernel/refusals.ts";
 import {
-  appendLedgerEvent,
-  buildWorkspaceLeaseEvent,
-} from "../src/ledger.ts";
-import { GovernanceRefusal, refusal, type StructuredRefusal } from "../src/refusals.ts";
-import {
-  acquireWorkspaceLease,
-  defaultWorkspaceLeaseDir,
   ENV_WORKSPACE_REGISTRY,
   loadWorkspaceRegistry,
   resolveWorkspace,
   type ValidatedWorkspace,
   type WorkspaceAccess,
+} from "../src/kernel/workspace.ts";
+import {
+  acquireWorkspaceLease,
+  defaultWorkspaceLeaseDir,
   type WorkspaceLease,
   leaseAcquisitionOutcome,
   type LeaseReleaseOutcome,
-} from "../src/workspace.ts";
+} from "../src/governance/workspace-lease.ts";
 
 export interface DelegationWorkspaceSpec {
   workspace_id: string;
@@ -27,7 +26,7 @@ export interface DelegationWorkspaceSpec {
  * Tools that cannot change a worktree.
  *
  * **`tool:delegate` is deliberately NOT here, and that is a scope decision.** It was added, and it was true of
- * the capability and false of the code: a routed child's cwd IS the leased root, `PI_GRANTS_LEDGER` was
+ * the capability and false of the code: a routed child's cwd IS the leased root, `PI_DADDY_LEDGER` was
  * passed through relative (`init` scaffolds `.pi/grants.jsonl`), and a `read` lease takes no kernel lock — so
  * two delegating children classified `read` both created `.pi/` in one worktree and neither excluded the
  * other. Making `tool:delegate` non-writing requires first making every child-inherited path absolute, and
@@ -75,19 +74,21 @@ export async function prepareDelegationWorkspace(input: {
   ledgerPath?: string;
 }): Promise<PreparedWorkspace> {
   if (input.correlation?.workspace_id && input.correlation.workspace_id !== input.spec.workspace_id) {
-    throw new GovernanceRefusal(refusal(
-      "APPROVAL_SCOPE_MISMATCH",
-      `correlation workspace ${input.correlation.workspace_id} does not match requested workspace ${input.spec.workspace_id}`,
-      { workspace_id: input.spec.workspace_id },
-    ));
+    throw new GovernanceRefusal(
+      refusal(
+        "APPROVAL_SCOPE_MISMATCH",
+        `correlation workspace ${input.correlation.workspace_id} does not match requested workspace ${input.spec.workspace_id}`,
+        { workspace_id: input.spec.workspace_id },
+      ),
+    );
   }
   const registryPath = process.env[ENV_WORKSPACE_REGISTRY];
   if (!registryPath) {
-    throw new GovernanceRefusal(refusal(
-      "WORKSPACE_NOT_REGISTERED",
-      `${ENV_WORKSPACE_REGISTRY} is required when a delegation names a workspace`,
-      { workspace_id: input.spec.workspace_id },
-    ));
+    throw new GovernanceRefusal(
+      refusal("WORKSPACE_NOT_REGISTERED", `${ENV_WORKSPACE_REGISTRY} is required when a delegation names a workspace`, {
+        workspace_id: input.spec.workspace_id,
+      }),
+    );
   }
   const workspace = await resolveWorkspace(await loadWorkspaceRegistry(registryPath), input.spec.workspace_id);
   let lease: WorkspaceLease | undefined;
@@ -122,9 +123,10 @@ export async function prepareDelegationWorkspace(input: {
     // A load-bearing ledger failure can happen after the kernel lock was acquired. Release before trying
     // to record the refusal, or this live parent would strand its own writer lease until process exit.
     await lease?.release("setup-failed");
-    const structured: StructuredRefusal = error instanceof GovernanceRefusal
-      ? { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) }
-      : refusal("WORKSPACE_LEASE_STALE", `workspace lease failed (${String(error)})`);
+    const structured: StructuredRefusal =
+      error instanceof GovernanceRefusal
+        ? { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) }
+        : refusal("WORKSPACE_LEASE_STALE", `workspace lease failed (${String(error)})`);
     if (input.ledgerPath) {
       await appendLedgerEvent(
         { path: input.ledgerPath, strict: true },

package/herdr-plugin/herdr-plugin.toml

@@ -14,5 +14,5 @@ command = [
   "node",
   "--input-type=module",
   "-e",
-  "import('node:url').then(({ pathToFileURL }) => import(pathToFileURL(process.env.HERDR_PLUGIN_ROOT + '/../dist/dashboard-cli.js').href)).then(m => m.runDashboard()).catch(e => { console.error(e); process.exitCode = 1; })"
+  "import('node:url').then(({ pathToFileURL }) => import(pathToFileURL(process.env.HERDR_PLUGIN_ROOT + '/../dist/products/dashboard-cli.js').href)).then(m => m.runDashboard()).catch(e => { console.error(e); process.exitCode = 1; })"
 ]