pi-daddy 0.27.4 → 0.32.0

package/extensions/init-command.ts

@@ -7,11 +7,12 @@
  * guard exists to defend — every wiring bug this package has had lived in that file.
  */
 
-import { discoverSkillPackages } from "../src/skill-packages.ts";
-import { applyInit, planInit } from "../src/init.ts";
-import { registeredWorkspaceIds } from "../src/workspace.ts";
-import { grantStorePath, projectLedgerPath, saveGrant } from "../src/grant-store.ts";
-import { expandSubsumed, SUBSUMPTION, type Capability } from "../src/resolve.ts";
+import { discoverSkillPackages } from "../src/kernel/skill-packages.ts";
+import { applyInit, GITIGNORE_REINCLUDE_LINES, planInit, settingsIgnoredByGit } from "../src/governance/init.ts";
+import { PI_PROJECT_DIR } from "../src/kernel/project-paths.ts";
+import { registeredWorkspaceIds } from "../src/kernel/workspace.ts";
+import { grantStorePath, projectLedgerPath, saveGrant } from "../src/governance/grant-store.ts";
+import { expandSubsumed, SUBSUMPTION, type Capability } from "../src/kernel/resolve.ts";
 import type { GrantsSession } from "./session.ts";
 
 /**
@@ -55,7 +56,7 @@ export async function runInit(
   const outcome = await applyInit(plan);
   const lines = [
     `grants: ${plan.skills.length} definition(s) from ${packages.map((p) => `${p.name}@${p.version}`).join(", ")}`,
-    `  using ${plan.skills.filter(s => s.referenced).length} enabled definition(s) in place; no copies`,
+    `  using ${plan.skills.filter((s) => s.referenced).length} enabled definition(s) in place; no copies`,
     `  wrote ${outcome.written.length}, kept ${outcome.kept.length} already present` +
       `${outcome.failed.length > 0 ? `, ${outcome.failed.length} FAILED` : ""}`,
   ];
@@ -71,7 +72,7 @@ export async function runInit(
 
   for (const [capability, neededBy] of plan.withheldCapabilities) {
     // **Do not ask a question whose answer cannot matter.** `tool:bash` subsumes `write`, `edit` and
-    // `edit-diff` (`SUBSUMPTION`, `src/resolve.ts`), so once bash is granted those are already conferred.
+    // `edit-diff` (`SUBSUMPTION`, `src/kernel/resolve.ts`), so once bash is granted those are already conferred.
     // The first version asked anyway: an operator could answer *no* to `tool:write`, watch `/grants` allow
     // `build` with `tool:write`, and reasonably conclude the dialog was decorative. It was — that is R-47's
     // shape, a control that appears to do something and does not, inside a control built to prevent it.
@@ -84,11 +85,11 @@ export async function runInit(
       continue;
     }
     // The consequence sentence is per capability, and it reads the gate **in effect for this session** —
-    // `session.gated`, which is `PI_GRANTS_GATED` when the operator set it and `DEFAULT_GATED` otherwise.
+    // `session.gated`, which is `PI_DADDY_GATED` when the operator set it and `DEFAULT_GATED` otherwise.
     //
     // The first version read `DEFAULT_GATED` directly, which is the compile-time constant `["tool:bash"]`, and
     // `tool:bash` is consumed by the branch above — so the branch was **unreachable in every configuration**,
-    // and with `PI_GRANTS_GATED="tool:bash,tool:write"` (the value `renderGrantEnv` itself suggests) the
+    // and with `PI_DADDY_GATED="tool:bash,tool:write"` (the value `renderGrantEnv` itself suggests) the
     // dialog still printed the exact false sentence the fix claimed to remove. Dead code beside a claim that
     // it worked, which is this project's failure mode, in the commit correcting that failure mode.
     // No subsumption closure here, and the absence is deliberate. A `|| SUBSUMPTION[capability]…` disjunct was
@@ -124,7 +125,7 @@ export async function runInit(
   if (saved !== "saved") {
     lines.push(
       `  NOT STORED — ${saved === "busy" ? "another session holds the grant store" : "the store could not be written"}. ` +
-        `Nothing was changed; this session's grant is unchanged. Retry, or export PI_GRANTS_GRANT yourself.`,
+        `Nothing was changed; this session's grant is unchanged. Retry, or export PI_DADDY_GRANT yourself.`,
     );
     ctx.ui.notify(lines.join("\n"), "error");
     return;
@@ -139,7 +140,7 @@ export async function runInit(
 
   lines.push(
     `  stored at ${grantStorePath(ctx.cwd)} — outside this project, so no child can rewrite it`,
-    `  ledger ${ledger} — default for future pi sessions; PI_GRANTS_LEDGER still overrides it`,
+    `  ledger ${ledger} — default for future pi sessions; PI_DADDY_LEDGER still overrides it`,
   );
   if (granted.length > 0) lines.push(`  GRANTED: ${granted.join(", ")}`);
   if (alreadyConferred.length > 0) {
@@ -154,9 +155,14 @@ export async function runInit(
     lines.push(
       `  ROUTABLE WORKSPACES, listed and NOT granted: ${plan.routableWorkspaces.join(", ")}`,
       `    routing a child to one needs its id in the grant (ADR-0035); add the ones this project may use to ` +
-        `${plan.grantEnvPath}. Which worktree a child starts in is not something a package can declare for you.`,
+        `${plan.settingsPath}. Which worktree a child starts in is not something a package can declare for you.`,
     );
   }
+  if ((await settingsIgnoredByGit(plan.settingsPath)) === true)
+    lines.push(
+      `  NOTE: git ignores ${plan.settingsPath} (your root .gitignore covers ${PI_PROJECT_DIR}/), so the reviewable record ` +
+        `cannot be committed until you add: ${GITIGNORE_REINCLUDE_LINES.join("  ")}`,
+    );
   lines.push(`  live now (${finalGrant.length} capabilities) — no restart. /grants shows the verdicts.`);
   ctx.ui.notify(lines.join("\n"), "info");
 }

package/extensions/reload-environment.ts

@@ -1,7 +1,11 @@
-import { GRANT_ENV_KEYS } from "../src/propagation.ts";
+import { GRANT_ENV_KEYS } from "../src/kernel/propagation.ts";
 
 /** The root baseline and latest child publication for one real Pi session owner. */
-export interface ReloadLifecycle { root: Record<string, string | undefined>; published?: Record<string, string | undefined> }
+export interface ReloadLifecycle {
+  root: Record<string, string | undefined>;
+  published?: Record<string, string | undefined>;
+  activityRootId?: string;
+}
 type SessionOwner = object;
 
 interface ReloadState {
@@ -15,10 +19,10 @@ function state(): ReloadState {
 }
 
 function snapshot(): Record<string, string | undefined> {
-  return Object.fromEntries(GRANT_ENV_KEYS.map(key => [key, process.env[key]]));
+  return Object.fromEntries(GRANT_ENV_KEYS.map((key) => [key, process.env[key]]));
 }
 function same(left: Record<string, string | undefined>, right: Record<string, string | undefined>): boolean {
-  return GRANT_ENV_KEYS.every(key => left[key] === right[key]);
+  return GRANT_ENV_KEYS.every((key) => left[key] === right[key]);
 }
 function withRoot(root: Record<string, string | undefined>): NodeJS.ProcessEnv {
   return { ...process.env, ...root };
@@ -35,7 +39,10 @@ export function beginExtensionLifecycle(): { environment: NodeJS.ProcessEnv; lif
  * A matching latest publication is child state from a known owner, not an explicit replacement for this
  * owner. An unmatched environment change is an explicit root replacement for THIS owner only.
  */
-export function bindReloadLifecycle(owner: SessionOwner, provisional: ReloadLifecycle): {
+export function bindReloadLifecycle(
+  owner: SessionOwner,
+  provisional: ReloadLifecycle,
+): {
   lifecycle: ReloadLifecycle;
   environment: NodeJS.ProcessEnv;
 } {

package/extensions/run-delegation.ts

@@ -12,8 +12,8 @@
  */
 
 import { nativeDelegationContext } from "./delegation-native.ts";
-import { DELEGATE_SUBJECT, shouldSeekApproval } from "../src/approval.ts";
-import { planDelegation } from "../src/delegate.ts";
+import { DELEGATE_SUBJECT, shouldSeekApproval } from "../src/kernel/approval.ts";
+import { planDelegation } from "../src/kernel/delegate.ts";
 import {
   obtainApprovals,
   republishable,
@@ -22,11 +22,11 @@ import {
   type ApprovalOutcome,
   type ApprovalUIContext,
 } from "./approvals.ts";
-import type { InheritableApproval } from "../src/approval.ts";
+import type { InheritableApproval } from "../src/kernel/approval.ts";
 import type { GrantsSession } from "./session.ts";
-import type { CorrelationMetadata } from "../src/correlation.ts";
-import { preflightModel, type ModelCatalogue } from "../src/model-preflight.ts";
-import { GovernanceRefusal, refusal as structuredRefusal } from "../src/refusals.ts";
+import type { CorrelationMetadata } from "../src/kernel/correlation.ts";
+import { preflightModel, type ModelCatalogue } from "../src/kernel/model-preflight.ts";
+import { GovernanceRefusal, refusal as structuredRefusal } from "../src/kernel/refusals.ts";
 import { executePlannedChild, type DelegationOutcome } from "./execute-child.ts";
 import { recordDelegationDecision, type ApprovalLedgerFacts } from "./delegation-ledger.ts";
 import type { ExecutionOccurrenceIds } from "./execution-occurrence.ts";
@@ -155,9 +155,7 @@ export async function planWithApprovals(
       plan = {
         ...plan,
         reason: approval.reason,
-        ...(approval.refusalCode
-          ? { refusal: structuredRefusal(approval.refusalCode, approval.reason) }
-          : {}),
+        ...(approval.refusalCode ? { refusal: structuredRefusal(approval.refusalCode, approval.reason) } : {}),
       };
     }
   } catch (error) {
@@ -204,7 +202,7 @@ export async function runOneDelegation(
    */
   options: {
     /** Actual public execute argument, never read from model-authored correlation or output. */
-    toolCallId?: string; declaredWork?: GrantsSession["declaredWork"];
+    toolCallId?: string;
     /** Progress for the parent's status block (ADR-0032). Display only. */
     onProgress?: (update: {
       /** Appended (process executor: a genuine byte stream). */
@@ -260,13 +258,13 @@ export async function runOneDelegation(
     boundContextId: spec.correlation?.context_id,
   };
 
-  // ADR-0031: herdr was DEMANDED (`PI_GRANTS_HERDR=1`) and is not answering. Refused rather than relocated —
+  // ADR-0031: herdr was DEMANDED (`PI_DADDY_HERDR=1`) and is not answering. Refused rather than relocated —
   // the operator chose that over falling back, so the ledger can never name a child that ran somewhere nobody
   // chose.
   //
   // **Decided BEFORE the gate, and the ordering is a fix.** This sat after `planWithApprovals`, which opens the
   // approval dialog — so with herdr down a human was asked to approve `tool:bash`, answered *Always*, and was
-  // then refused anyway. Measured: the answer still reached `process.env.PI_GRANTS_APPROVED`, still wrote a
+  // then refused anyway. Measured: the answer still reached `process.env.PI_DADDY_APPROVED`, still wrote a
   // **30-day project-wide** entry to the persisted store, and still produced a ledger line asserting a human
   // approved `bash` for a child that never existed. A refused operation must not leave authority behind, and
   // asking for permission that cannot be used is R-25's fatigue shape with nothing bought.
@@ -281,7 +279,12 @@ export async function runOneDelegation(
     session.modelResolutionCache,
     session.allowUnresolvedModels,
   );
-  const {extra,refusal:nativeRefusal}=await nativeDelegationContext(session,ids,budget,Boolean(executorRefusal||modelRefusal));
+  const { extra, refusal: nativeRefusal } = await nativeDelegationContext(
+    session,
+    ids,
+    budget,
+    Boolean(executorRefusal || modelRefusal),
+  );
   executorRefusal ||= nativeRefusal;
   let preparedWorkspace: PreparedWorkspace | undefined;
   let approvalOutcome: ApprovalOutcome | undefined;
@@ -309,9 +312,10 @@ export async function runOneDelegation(
         plan = gated.plan;
         approvalOutcome = gated.approval;
       } catch (error) {
-        const value = error instanceof GovernanceRefusal
-          ? { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) }
-          : structuredRefusal("WORKSPACE_LEASE_STALE", `workspace setup failed (${String(error)})`);
+        const value =
+          error instanceof GovernanceRefusal
+            ? { code: error.code, message: error.message, ...(error.details ? { details: error.details } : {}) }
+            : structuredRefusal("WORKSPACE_LEASE_STALE", `workspace setup failed (${String(error)})`);
         plan = { ...plan, ok: false, reason: value.message, refusal: value };
       }
     }
@@ -340,8 +344,14 @@ export async function runOneDelegation(
   // The capability decision provisions the child, so this append remains load-bearing and fails closed.
   try {
     await recordDelegationDecision({
-      session, plan, ids, agent: spec.agent, taskFrom, taskFromExecutionId,
-      approval: approvalOutcome, approvalFacts,
+      session,
+      plan,
+      ids,
+      agent: spec.agent,
+      taskFrom,
+      taskFromExecutionId,
+      approval: approvalOutcome,
+      approvalFacts,
     });
   } catch (error) {
     plan = {
@@ -389,7 +399,7 @@ export async function runOneDelegation(
     childId: ids.childId,
     executionId: ids.executionId,
     parentExecutionId: ids.parentExecutionId,
-    toolCallId: options.toolCallId, declaredWork: options.declaredWork,
+    toolCallId: options.toolCallId,
     cwd: ctx.cwd,
     preparedWorkspace,
     signal,

package/extensions/session-environment.ts

@@ -1,28 +1,42 @@
-import { parseInherited } from "../src/approval.ts";
-import { DELEGATE_CAPABILITY } from "../src/delegate.ts";
-import { budgetFromEnv } from "../src/fanout.ts";
-import { WILDCARD } from "../src/pi-tools.ts";
+import { parseInherited } from "../src/kernel/approval.ts";
+import { DELEGATE_CAPABILITY } from "../src/kernel/delegate.ts";
+import { budgetFromEnv } from "../src/kernel/fanout.ts";
+import { WILDCARD } from "../src/kernel/pi-tools.ts";
 import {
-  depthConfig, deriveOwnGrant, gatedFromEnv, ENV_APPROVED, ENV_DEPTH, ENV_EXECUTION_ID, ENV_FANOUT,
-  ENV_GATED, ENV_GRANT, ENV_LEDGER, ENV_MAX_DEPTH, ENV_PARENT_ID, parseList,
-} from "../src/propagation.ts";
+  depthConfig,
+  deriveOwnGrant,
+  gatedFromEnv,
+  ENV_APPROVED,
+  ENV_DEPTH,
+  ENV_EXECUTION_ID,
+  ENV_FANOUT,
+  ENV_GATED,
+  ENV_GRANT,
+  ENV_LEDGER,
+  ENV_MAX_DEPTH,
+  ENV_PARENT_ID,
+  parseList,
+} from "../src/kernel/propagation.ts";
 import { storedGrantSessionState } from "./stored-grant-session.ts";
-import { chooseExecutor, ENV_HERDR } from "../src/executor.ts";
-import { ENV_ALLOW_UNRESOLVED_MODELS } from "../src/model-preflight.ts";
+import { chooseExecutor, ENV_HERDR } from "../src/executors/executor.ts";
+import { ENV_ALLOW_UNRESOLVED_MODELS } from "../src/kernel/model-preflight.ts";
 import type { ReloadLifecycle } from "./reload-environment.ts";
-import type { GrantsSession } from "./session.ts";
+import { ENV_GOVERNANCE, type GrantsSession } from "./session.ts";
 
 /** Rebuild every authority-bearing factory input once session_start identifies its real SDK owner. */
 export function reconcileSessionEnvironment(
-  session: GrantsSession, environment: NodeJS.ProcessEnv, lifecycle: ReloadLifecycle,
+  session: GrantsSession,
+  environment: NodeJS.ProcessEnv,
+  lifecycle: ReloadLifecycle,
 ): void {
   const grantRaw = environment[ENV_GRANT];
   const stored = storedGrantSessionState(grantRaw, session.storeCwd);
   const bounds = depthConfig(environment[ENV_DEPTH], environment[ENV_MAX_DEPTH]);
   const ledgerRaw = environment[ENV_LEDGER];
   session.ledgerFromEnvironment = ledgerRaw !== undefined;
-  session.governed = stored.governed;
-  session.inherited = stored.inherited;
+  const governanceOff = environment[ENV_GOVERNANCE]?.trim() === "off" || environment[ENV_GOVERNANCE]?.trim() === "0";
+  session.governed = !governanceOff;
+  session.inherited = governanceOff ? stored.inherited : stored.governed ? stored.inherited : [WILDCARD];
   session.depth = bounds.depth;
   session.maxDepth = bounds.maxDepth;
   session.malformedBounds = bounds.malformed;
@@ -32,9 +46,12 @@ export function reconcileSessionEnvironment(
   session.ownSpawnId = environment[ENV_PARENT_ID]?.trim() || `d${session.depth}`;
   session.ownExecutionId = environment[ENV_EXECUTION_ID]?.trim() || undefined;
   session.fanoutBudget = budgetFromEnv(environment[ENV_FANOUT]);
-  session.mayDelegate = !session.governed || session.inherited.includes(DELEGATE_CAPABILITY) || session.inherited.includes(WILDCARD);
+  session.mayDelegate =
+    !session.governed || session.inherited.includes(DELEGATE_CAPABILITY) || session.inherited.includes(WILDCARD);
   session.allowUnresolvedModels = environment[ENV_ALLOW_UNRESOLVED_MODELS] === "1";
   session.reloadLifecycle = lifecycle;
+  session.activityRootId = lifecycle.activityRootId ?? session.activityRootId;
+  lifecycle.activityRootId = session.activityRootId;
   session.inheritedApprovals = parseInherited(environment[ENV_APPROVED]);
   session.ownGrant = deriveOwnGrant(session.inherited, null);
   session.observed = false;

package/extensions/session-report.ts

@@ -17,12 +17,22 @@
  */
 
 import { existsSync } from "node:fs";
-import { legacyApprovalsPath, sharedApprovalsPath } from "../src/approval-store.ts";
-import { verifyLedger } from "../src/ledger.ts";
-import { AGENT_WILDCARD } from "../src/resolve.ts";
+import { legacyApprovalsPath, sharedApprovalsPath } from "../src/governance/approval-store.ts";
+import { verifyLedger } from "../src/governance/ledger.ts";
+import { AGENT_WILDCARD } from "../src/kernel/resolve.ts";
 import { planWithApprovals } from "./run-delegation.ts";
 import type { GrantsSession } from "./session.ts";
 import { renderSpawnableSummary, summariseSpawnable } from "./spawn-summary.ts";
+import {
+  approvalsPath,
+  grantStorePath,
+  legacyGrantEnvPath,
+  legacyProjectLedgerPath,
+  legacyUserApprovalsPath,
+  legacyUserGrantStorePath,
+  projectLedgerPath,
+  projectSettingsPath,
+} from "../src/kernel/project-paths.ts";
 
 /**
  * The slice of pi's context this module needs: a working directory and somewhere to speak.
@@ -55,6 +65,40 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
   // different reason for not migrating: splitting it by `cwd` would be lossless, and it is still declined
   // because one-shot migration code in the layer with nine defects buys less than one re-approval costs.
   try {
+    // ADR-0076 PR 3c moved the user-level stores under one pi-daddy/ directory WITHOUT migration (operator
+    // decision, following ADR-0020). Name what was left behind, so "why does it ask again" has an answer.
+    for (const [label, legacy, current, action] of [
+      [
+        "grant store",
+        legacyUserGrantStorePath(ctx.cwd),
+        grantStorePath(ctx.cwd),
+        "run /grants init to record this project's grant again",
+      ],
+      [
+        "approvals",
+        legacyUserApprovalsPath(ctx.cwd),
+        approvalsPath(ctx.cwd),
+        "answer the gate again; stored approvals are not migrated",
+      ],
+      [
+        "project ledger",
+        legacyProjectLedgerPath(ctx.cwd),
+        projectLedgerPath(ctx.cwd),
+        "it is imported once at session start; the old file is kept untouched",
+      ],
+      [
+        "grants.env",
+        legacyGrantEnvPath(ctx.cwd),
+        projectSettingsPath(ctx.cwd),
+        "it is no longer written or read; a shell that still sources it points PI_DADDY_LEDGER at the old ledger — delete the file",
+      ],
+    ] as const) {
+      if (existsSync(legacy) && !existsSync(current))
+        ctx.ui.notify(
+          `grants: ${label} found at its pre-0.30 location ${legacy} and not at ${current} — ${action}.`,
+          "warning",
+        );
+    }
     if (existsSync(sharedApprovalsPath())) {
       ctx.ui.notify(
         `grants: ignoring ${sharedApprovalsPath()} — approvals are now stored one file per governed ` +
@@ -85,15 +129,19 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
   // file" is not true of everything it covers. Paired with a shell that is every body on disk running
   // with `bash`. `docs/SPEC.md` calls the combination poor and nothing detected it, which is R-47's
   // shape in a control shipped one day later.
-  if (session.ownGrant.includes(AGENT_WILDCARD) && session.gated.length === 0 && session.ownGrant.includes("tool:bash")) {
+  if (
+    session.ownGrant.includes(AGENT_WILDCARD) &&
+    session.gated.length === 0 &&
+    session.ownGrant.includes("tool:bash")
+  ) {
     ctx.ui.notify(
-      `grants: PI_GRANTS_GRANT pairs agent:* with tool:bash and gates nothing — every SKILL.md in ` +
+      `grants: PI_DADDY_GRANT pairs agent:* with tool:bash and gates nothing — every SKILL.md in ` +
         `this project AND in ~/.pi/agent/skills (which other tools install into) may run with a shell. ` +
-        `Enumerate the agent: ids you mean, or leave PI_GRANTS_GATED at its default so bash is asked for.`,
+        `Enumerate the agent: ids you mean, or leave PI_DADDY_GATED at its default so bash is asked for.`,
       "warning",
     );
   }
-  // REMOVED 2026-08-21. This warned that an `agent:` id in `PI_GRANTS_GATED` "does NOT gate spawning that
+  // REMOVED 2026-08-21. This warned that an `agent:` id in `PI_DADDY_GATED` "does NOT gate spawning that
   // definition — a human is never asked". It was R-47's PARTIAL fix (0.11.1) and became false one release
   // later at 0.12.0, when ADR-0024's gate landed (`4673348`, "gating a definition asks before it runs") and
   // a gated `agent:<name>` began blocking the spawn until somebody approved it. ADR-0024's own Costs section
@@ -108,7 +156,7 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
   // no live case is the next stale claim. R-134.
   // R-34. `verifyLedger` existed and nothing ran it, so a torn line was detectable and undetected —
   // and a check an operator has to know to run is not a control, it is a feature. Setting
-  // `PI_GRANTS_LEDGER` already means "I want an audit trail"; noticing that the trail is damaged is
+  // `PI_DADDY_LEDGER` already means "I want an audit trail"; noticing that the trail is damaged is
   // part of keeping one.
   //
   // Corruption only, deliberately. The escalation count is a *query* — `/grants ledger` answers it —
@@ -122,7 +170,7 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
   // where an operator asked a direct question and deserves the failure — and this call is the only one
   // that makes it inside the blanket catch below. So an unreadable ledger threw here and cancelled every
   // remaining control **in silence**: no alarm, and not even the `holding [...]` line that is the one
-  // sign governance is on. Confirmed by execution — `PI_GRANTS_LEDGER` naming a directory produced ZERO
+  // sign governance is on. Confirmed by execution — `PI_DADDY_LEDGER` naming a directory produced ZERO
   // notifications from a governed session. A trail that cannot be read at all is a worse failure than a
   // torn line, and it was the one case this control said nothing about.
   if (session.ledgerPath) {
@@ -142,7 +190,7 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
         `grants: ledger ${session.ledgerPath} could not be read ` +
           `(${(error as { code?: string }).code ?? String(error)}) — nothing can be verified about this ` +
           `audit trail, and the first spawn will refuse rather than proceed unrecorded. Check that ` +
-          `PI_GRANTS_LEDGER names a writable FILE.`,
+          `PI_DADDY_LEDGER names a writable FILE.`,
         "error",
       );
     }
@@ -183,6 +231,8 @@ export async function reportSessionStart(session: GrantsSession, ctx: SessionRep
     ctx.ui.notify(`grants: executor — ${session.executor.disclosure}`, "error");
   }
 
+  if (!session.governed)
+    info.push("grants: governance off by PI_DADDY_GOVERNANCE; observation and the local timeline remain independent.");
   if (session.governed) {
     info.push(
       `grants: depth ${session.depth}/${session.maxDepth}, holding [${session.ownGrant.join(", ") || "nothing"}]`,