create-agdf 0.30.0 → 0.31.0

package/generated/plugins/copilot/agdf/runtime/create-agdf/generated/plugins/agdf/meta/contracts/sd-definition.md

@@ -33,6 +33,22 @@ PRD criterion exactly once to realization, authoritative owner, stable SDD IDs o
 and compatibility/risk. Never duplicate acceptance, invent scope/users or claim implementation.
 Retain actual sources/draft and a reasoned derivation review; structure alone is not semantic proof.
 
+Architecture Decisions use `SDD-...: decision; rationale: reason; consequence: trade-off`.
+Each bullet has one concrete decision statement, exactly one nonempty `rationale:` field and
+exactly one nonempty `consequence:` field (`trade-off:` is its alias, not an additional field).
+The readiness check distinguishes absent decision/rationale/consequence fields from unresolved
+author prompts and identifies the exact offending token and field. Quoted CLI syntax such as
+`done <id>` stays literal. An inline, parseable JSON object/array introduced immediately by
+`schema`, `JSON schema`, `schema example` or `JSON example` may use full quoted string values
+`"<uuid>"`, `"<string>"`, `"<non-empty string>"`, `"<number>"`, `"<integer>"`,
+`"<positive number>"`, `"<non-negative number>"`, `"<positive integer>"`,
+`"<non-negative integer>"`, `"<boolean>"`, `"<null>"`, `"<object>"` or `"<array>"`.
+This exception applies only to the decision clause, not type placeholders in JSON keys, arbitrary
+inline code, malformed JSON, or the rationale/consequence. Regular JSON keys such as `"todo"`
+are literal schema property names; angle-bracket prompts in keys remain unresolved.
+Unknown prompts such as `<choose encoding>`,
+`<why>`, `TBD` and `TODO` remain blockers; type notation cannot settle a material design choice.
+
 A decision that selects or changes a framework, library, external API, protocol, service or major
 version not already evidenced in the repository needs current authoritative sources through the
 host's available tools: official documentation/specification, release notes or migration guide of
@@ -60,8 +76,38 @@ A product-scope/acceptance conflict stays unresolved and returns to the earliest
 UR/PRD revision owner. Do not edit approved sources, invent a transition after downstream linking
 or manufacture answers; use supported revision/recovery and fresh source approval where required.
 
+### Realize brand-informed criteria
+
+For applicable design work, read the adopted PRD criteria together with the exact project brand
+source references retained by UX/PRD: path, version or content digest and relevant passages. Keep
+that source identity in the existing Ownership And Source Of Truth and Constraints And Compatibility
+sections and confirm the consumed version matches it. A framework example or another project's
+brand file cannot replace the selected source; brand context cannot silently expand approved
+product intent or acceptance.
+
+SD owns the concrete realization: design tokens, typography, layout, information hierarchy and
+controls. Record the relevant choices, reuse, rationale and trade-offs with the existing SDD IDs
+and map each approved criterion once through Acceptance Traceability. Preserve the approved
+perception and information priorities rather than inventing a parallel brand specification.
+
+In Test And Evidence Strategy, identify representative states, observable checks and the evidence
+needed to judge those criteria. Plan evidence for quality.md's UX Intent Fidelity matrix under the
+same PRD criterion IDs; its existing review owner produces that matrix at the appropriate stage.
+Add no second matrix, gate or automatic fidelity claim. A preview or source-file match is not
+implementation evidence or independent human acceptance. Non-applicable work requires no new brand
+file. Missing material design facts remain before_sd decisions below;
+product conflicts return to the existing PRD/UR revision owner.
+
 ## Explicit revision and recording
 
+A returned bound authoring continuation for an incomplete own unapproved draft already
+selects its correction route. Consume its authoring-inputs/material_call/recording_calls
+forms directly and use the supplied update_draft value. Do not dispatch this author again
+or add another intake for that same snapshot. The *_action revise route below is only for
+NEW editing intent on an already READY draft, and uses skill_id gate-check, never an author
+skill ID or a host skill alias. After saving, follow the returned continuation once.
+
+
 Before recording, use the continuation's resolved language and summary fields with
 gate-artifact-preparation's Language and approval summary preparation. A translated summary
 must be part of the draft before presentation, not deferred until a renderer failure.

package/generated/plugins/copilot/agdf/runtime/create-agdf/generated/plugins/agdf/meta/contracts/tp-definition.md

@@ -69,6 +69,14 @@ not independent proof of human provenance. Table headings may use levels two thr
 
 ## Recording and revision
 
+A returned bound authoring continuation for an incomplete own unapproved draft already
+selects its correction route. Consume its authoring-inputs/material_call/recording_calls
+forms directly and use the supplied update_draft value. Do not dispatch this author again
+or add another intake for that same snapshot. The *_action revise route below is only for
+NEW editing intent on an already READY draft, and uses skill_id gate-check, never an author
+skill ID or a host skill alias. After saving, follow the returned continuation once.
+
+
 A ready draft without new editing intent is presented unchanged. Explicit ready-draft revision uses
 gate-check intake true, intake_mode resume, exact run_id/expected_revision_id and tp_action revise
 (CLI --tp-action revise), exclusive of other source actions and continue_delivery. Approved changes

package/generated/plugins/copilot/agdf/runtime/create-agdf/generated/plugins/agdf/meta/contracts/ur-definition.md

@@ -42,7 +42,7 @@ For `phase: ur_definition`, use only the returned governance_target, run_id, rev
 template_path is the absolute, version-matched template owned by the installed plugin runtime.
 Repository copies under `.agdf/control/templates/` are derived scaffold references and never
 override this authoring source. Read the template without rewriting it; persist only artifact_path.
-A direct invocation first dispatches ur-definition; without a bound run follow the existing
+An already returned bound `ur_definition` continuation satisfies entry: consume its authoring inputs and writer forms directly. Do not repeat author dispatch or intake for that same snapshot. A direct invocation without such a continuation first dispatches ur-definition; without a bound run follow the existing
 resolve_delivery_run assignment, then gate-check intake/resume with its expected_revision_id.
 Never use AGDF_RUN_ID, cwd, discovery or a previous approval as authority. Missing, stale,
 foreign, invalid or approved bindings require fresh control routing; do not write.
@@ -104,7 +104,7 @@ follows its current-request language contract and does not change the artefact l
 
 Before recording a complete draft, when `approval_summary_required` is true, include exactly
 one `## <approval_summary_heading>` section using the supplied heading verbatim. Write a
-complete summary in the resolved presentation language covering problem, goal, affected users,
+complete summary in the resolved presentation language. Read `approval_summary_format.required_fields` from authoring-inputs: those exact list field declarations need concrete authored values; prose or a heading alone is not a named field. Cover problem, goal, affected users,
 scope, non-goals, acceptance signals, source ownership, risks/unknowns and next step.
 Do not truncate decision-relevant content or use ellipses. The existing approval renderer's
 limits and validation apply. This summary is editorial; the UR remains authoritative.
@@ -116,9 +116,13 @@ is required merely to complete an unapproved incomplete draft.
 
 A new draft is recorded through existing run-step --step ur --title <short title>, using
 --dir <governance_target> --run <run_id> --revision <revision_id>.
-For an already registered unapproved draft, require explicit user revision intent. Resume
-through gate-check with intake true, intake_mode resume, run_id, expected_revision_id and
-ur_action revise (CLI --ur-action revise). Ordinary intake of a ready draft still presents it.
+When this bound continuation returns a registered, incomplete unapproved draft, correct its
+readiness gaps directly through the supplied `ur_draft.replace` form. The existing authoring
+route already covers completing that same need; do not open another intake or dispatch.
+A deliberate change to an already READY registered draft outside that continuation still
+requires explicit user revision intent: enter via gate-check with intake true, intake_mode
+resume, run_id, expected_revision_id and ur_action revise (CLI --ur-action revise).
+Ordinary intake of a ready draft still presents it. Never substitute a field named revision.
 Stage the replacement and use ur_draft.replace with the current binding. The writer
 publishes the document and typed evidence atomically. Never edit bound bytes, reseal
 an unknown change or alter an approved UR or its approval.

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/command-registry.js

@@ -34,6 +34,7 @@ export const commandRegistry = Object.freeze([
   command("opencode-repo", { preferred: [" --dir <path>"], scaffold: [" --dir <path>"] }),
   command("init", { preferred: [" [--operation <original-uuid>]"], scaffold: [""] }),
   command('project-state', { local: [' --dir <absolute-git-root> [--json] [--language <tag>]'] }),
+  command('run-view', { local: [' --dir <absolute-git-root> [--json] [--language <tag>] [--run <run-id>]...'] }),
   command('operation-status', { local: [' --dir <absolute-git-root> --module project.initialize/<original-uuid> [--json] [--language <tag>]'] }),
   command("config", { scaffold: [" --language de"] }),
   command("target-check", { local: [` --json [--language <tag>] [--working-directory <absolute-path>] [--target-source ${TASK_TARGET_SOURCE_GRAMMAR} --primary-target <absolute-path>]`] }),
@@ -72,7 +73,7 @@ export function supportedCommandNames() {
 export function validateCommandOptions(options) {
   if (options.native && (options.target !== 'status' || options.surface !== 'codex' || !options.dirExplicit || !options.dirInputAbsolute))
     throw Error('--native requires status --surface codex --dir <absolute-target>.');
-  if (['project-state', 'operation-status'].includes(options.target)) {
+  if (['project-state', 'operation-status', 'run-view'].includes(options.target)) {
     if (!options.dirExplicit || !options.dirInputAbsolute) throw Error('Project reads require an explicit absolute --dir Git root.');
     if (options.target === 'operation-status' && !/^project\.initialize\/[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}$/u.test(options.contractModule ?? ''))
       throw Error('operation-status requires --module project.initialize/<original-uuid>.');

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/parse-args.js

@@ -68,6 +68,7 @@ export function parseArgs(argv, dependencies = {}) {
   let generationTimeoutMs = 30000;
   let generationCostUnits = 5;
   let runId;
+  const runIds = [];
   let gate;
   let revisionId;
   let response;
@@ -161,6 +162,7 @@ export function parseArgs(argv, dependencies = {}) {
 
     if (arg === "--run") {
       runId = requiredValue(args, i, arg);
+      runIds.push(runId);
       i += 1;
       continue;
     }
@@ -363,10 +365,10 @@ export function parseArgs(argv, dependencies = {}) {
     throw new CliUsageError("Source revision identity and evidence flags may not repeat");
   }
   if (documentServer !== undefined && target !== 'render-document') throw new CliUsageError('--server requires render-document');
-  if (['project-state', 'operation-status'].includes(target)) {
-    const allowed = new Set(['--dir', '--json', '--language', '--lang', ...(target === 'operation-status' ? ['--module'] : [])]);
-    if ([...flagCounts].some(([flag, count]) => count !== 1 || !allowed.has(flag)))
-      throw new CliUsageError('Project reads accept only unique --dir, --json, --language and operation-status --module selectors.');
+  if (['project-state', 'operation-status', 'run-view'].includes(target)) {
+    const allowed = new Set(['--dir', '--json', '--language', '--lang', ...(target === 'operation-status' ? ['--module'] : []), ...(target === 'run-view' ? ['--run'] : [])]);
+    if ([...flagCounts].some(([flag, count]) => (count !== 1 && flag !== '--run') || !allowed.has(flag)))
+      throw new CliUsageError('Project reads accept only unique --dir, --json, --language, operation-status --module and repeatable run-view --run selectors.');
   }
   if (documentRequest && target !== 'render-document') throw new CliUsageError('--request requires render-document');
   if (target === 'render-document') {
@@ -462,6 +464,7 @@ export function parseArgs(argv, dependencies = {}) {
       model,
       generateCandidates,
       runId,
+      ...(target === 'run-view' ? { runIds } : {}),
       gate,
       revisionId,
       response,

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/project-read-command.js

@@ -1,6 +1,35 @@
 import { createCoreServices } from '#agdf-core';
+import { readRunView } from '#agdf-core/companion/run-view.js';
 import { resources, resolveConfiguredChatLanguage } from '../runtime/control-context.js';
 import { cliGitObservation } from '../control-evaluation/git-observation.js';
+import { RUN_ID_PATTERN } from '#agdf-core/control-state/run-identity.js';
+import { CliUsageError } from './parse-args.js';
+
+// An explicit --language wins; otherwise the configured chat language. A configuration that cannot be
+// resolved (unsupported layout, invalid value) must not hide the store diagnosis (PRD AC-002), so the
+// language is left to Core as executeProjectRead does: an unsupported store is reported in `store`,
+// an invalid configuration as the evaluation error of every evaluated run (CR finding CIR-05; both
+// cases are covered by run-view-command-test.js).
+const readLanguage = options => {
+  if (options.languageExplicit) return options.language?.chat_language;
+  try { return resolveConfiguredChatLanguage(options.dir); } catch { return undefined; }
+};
+
+// Read-only companion run view (SD SDD-001): the status card fields of every active or unreadable
+// run of one project root plus every run named with --run, versioned run-view/1. Writes nothing.
+// Exit 0 for a complete view, 2 when the store is unavailable or has no control folder.
+export function executeRunView(options, io = console) {
+  // A malformed run id is a usage error, never an evaluated run of its own (CR finding C3).
+  const invalid = (options.runIds ?? []).find(runId => !RUN_ID_PATTERN.test(runId));
+  if (invalid !== undefined) throw new CliUsageError(`run-view --run requires a run id (${RUN_ID_PATTERN}); got ${JSON.stringify(invalid)}.`);
+  const view = readRunView(options.dir, { language: readLanguage(options), runIds: options.runIds ?? [] });
+  if (options.json) io.log(JSON.stringify(view, null, 2));
+  else {
+    io.log(`AGDF run-view: ${view.store.status}${view.store.reason ? ` (${view.store.reason})` : ''}`);
+    for (const run of view.runs) io.log(`- ${run.run_id}: ${run.evaluated ? `${run.status} · ${run.current_gate} · ${run.next_step_text}` : run.lifecycle ?? 'unreadable'}`);
+  }
+  return view.store.status === 'ok' ? 0 : 2;
+}
 
 // CLI syntax only. Target confirmation, facts and original-operation semantics
 // stay with the same inspect owner used by MCP.

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/cli/validation-handlers.js

@@ -1,5 +1,5 @@
 import { executeRunAlias } from './run-command-aliases.js';
-import { executeProjectRead } from './project-read-command.js';
+import { executeProjectRead, executeRunView } from './project-read-command.js';
 import { localePack } from '#agdf-core/interaction-presentation.js';
 import { renderCodexDocument } from './codex-document-command.js';
 import { readFileSync, lstatSync, openSync, fstatSync, closeSync, constants } from "node:fs";
@@ -46,6 +46,7 @@ export function createValidationHandlers(io = console) {
   } }).dispatch;
   return new Map([
     ...['project-state', 'operation-status'].map(name => [name, options => executeProjectRead(options, io)]),
+    ['run-view', options => executeRunView(options, io)],
     ['render-document', options => renderCodexDocument(options)],
     ...['run-create', 'run-present', 'run-approve', 'run-step', 'run-revise', 'run-close'].map(name => [name, options => executeRunAlias(options, io)]),
     ...Object.entries(commandGroupRoutes).map(([route, group]) => [route, options => {

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/mcp-dispatch-runtime.js

@@ -7,11 +7,30 @@ import { createPresentationDelivery } from '#agdf-core/control-state/presentatio
 import { mcpControlContinuation } from '#agdf-core/skill-dispatch/mcp-continuation.js';
 import { inspectRunInputResolution } from '#agdf-core/control-state/run-input-resolution.js';
 import { assertMcpControlReadBoundary } from "#agdf-core/control-read-boundary.js";
+import { knownExecutionCode, validExecutionFacts } from '#agdf-core/mcp-tool-errors.js';
+import { createCompanionJournal } from '#agdf-core/companion/journal.js';
 import { existsSync, lstatSync, realpathSync } from 'node:fs';
 import { isAbsolute } from 'node:path';
 import { composeMcpProtocolRuntime, errorSupport, inspectMcpDispatcherRuntime, configuredMcpCommandGroups } from './mcp-protocol-runtime.js';
 export { inspectMcpDispatcherRuntime, configuredMcpCommandGroups, CONTROL_INSPECT_FUNCTION_DEFINITION, SKILL_DISPATCH_FUNCTION_DEFINITION,
   parseControlInspectFunctionArguments, parseSkillDispatchFunctionArguments, serializeSkillDispatchResult, DECISION_UI_URI, OWNED_LOCK_CHANNEL, releaseAbandonedOwnedLock } from './mcp-protocol-runtime.js';
+// Core reasons that the tool-error contract names differently. Core's command service maps
+// RECOVERY_REQUIRED the same way and rejects the others under these existing codes.
+const PREPARATION_REASONS = Object.freeze([
+  [/RECOVERY_REQUIRED/iu, 'recovery_required'],
+  [/^AGDF_PLANNED_SOURCE_STALE$/u, 'planning_source_stale'],
+  [/^(?:run_state_invalid|run_id_invalid)$/u, 'invalid_run'],
+  [/^AGDF_CONTROL_LAYOUT_MIGRATION_REQUIRED$/u, 'control_layout_unsupported'],
+]);
+// Dispatch preparation only reads the input context and grants staged material; no command has
+// been dispatched yet. Its failures therefore carry typed not_dispatched facts, so the facade and
+// generation call sites report a rejected command with its classified reason, never an unknown effect.
+export function preDispatchFailure(error) {
+  if (validExecutionFacts(error?.facts)) return Object.assign(error, { facts: { ...error.facts, dispatch: 'not_dispatched' } });
+  const reason = String(error?.message ?? '');
+  const code = knownExecutionCode(PREPARATION_REASONS.find(([pattern]) => pattern.test(reason))?.[1] ?? reason);
+  return Object.assign(new Error(code), { facts: { code, dispatch: 'not_dispatched' } });
+}
 export async function createMcpCockpitRuntime({ surface, cockpitDir, cockpitMode, inspected = inspectMcpDispatcherRuntime() } = {}) {
   const pluginMode = cockpitMode === 'plugin';
   if (cockpitMode !== undefined && !pluginMode || pluginMode && (surface !== 'codex' || cockpitDir !== undefined)
@@ -66,6 +85,9 @@ export function createMcpDispatchRuntime({ surface, inspected = inspectMcpDispat
     commandGroups, runtimeControl, materialGrants, gitObservation: cliGitObservation,
     observeDoctor: (root, input, signal) => diagnostic.observe(root, input, signal),
   } });
+  // Companion events (companion core SDD-006): the executing process journals each final command result
+  // once, below the data root the launcher hands over; review facts read the sealed material here.
+  const journal = createCompanionJournal({ sealedFiles: transferId => services.material.sealedFiles(transferId) });
   const execute = input => mcpControlContinuation(input, services.dispatch(input), commandGroups);
   const executeInspect = services.inspect;
   const protocol = composeMcpProtocolRuntime({ surface, inspected, commandGroups, execute, executeInspect, inputContext, executionContext,
@@ -76,25 +98,28 @@ export function createMcpDispatchRuntime({ surface, inspected = inspectMcpDispat
       : input.command.kind === 'presentation.deliver' ? delivery.deliver(input, host) : services.command(group, input) });
   return Object.freeze({ ...protocol,
     verifyProducer,
-    prepareDispatch(name, input) { return { inputContext: protocol.inputContextFor(input), materialGrants: ['agdf_record', 'agdf_revise', 'agdf_closeout'].includes(name) ? services.material.grants(input) : [] }; },
+    prepareDispatch(name, input) {
+      try {
+        return { inputContext: protocol.inputContextFor(input), materialGrants: ['agdf_record', 'agdf_revise', 'agdf_closeout'].includes(name) ? services.material.grants(input) : [] };
+      } catch (error) { throw preDispatchFailure(error); }
+    },
     readBudget,
     delivery,
+    observeOutcome: (name, input, result) => journal.observe(name, input, result),
     async postprocessToolResult(name, input, result) {
       const configuration = protocol.configurationProjection(input);
       if (configuration && name === 'agdf_inspect' && result.report) result = { ...result, report: { ...result.report, effective_configuration: configuration } };
       if (['agdf_record', 'agdf_revise', 'agdf_closeout'].includes(name)) services.material.settle(input, result);
       if (name !== 'agdf_prepare' || input.command?.kind !== 'presentation.prepare' || !result.family_result?.text) return result;
       delivery.remember(input, result);
-      const prepared = result.family_result, { operation_id, ...binding } = input;
+      const prepared = result.family_result;
       return { ...result, presentation_delivery: { mode: 'prepared', text: '', presentation_id: prepared.presentation_id,
         document_digest: prepared.document_digest, authorizes: false,
         ...(prepared.preview_review ? { preview_review: { operation: 'presentation-preview', version: prepared.preview_review.descriptor.version,
           content_digest: prepared.preview_review.rendered_digest, access_state: 'not_observed', target_id: input.target_id,
           run_id: input.run_id, gate: 'PRD', expected_revision_id: input.expected_revision_id, presentation_id: prepared.presentation_id } } : {}),
-        instruction: 'Prepared, not delivered. Optionally open agdf_decision_view as a non-primary preview. Then presentation.deliver selects once. Default route markdown; no second summary.',
-        next_calls: [{ tool: 'agdf_prepare', arguments: { ...binding, command: { kind: 'presentation.deliver',
-          payload: { gate: input.command.payload.gate, presentation_id: prepared.presentation_id, route: 'markdown' } } },
-          required_input: { operation_id: 'Generate a new UUID for delivery; no gate approval is required.' } }] } };
+        instruction: 'Prepared, not delivered. Optionally open agdf_decision_view as a non-primary preview. Follow the authoritative top-level next action for presentation.deliver; its original UUID and binding are already supplied. No second summary and no generated delivery UUID.',
+        next_action_source: 'next_calls' } };
     },
     async close() { services.material.close(); delivery.close(); await diagnostic.close(); },
     inspectOwnership() { const d = diagnostic.inspectOwnership(); return { diagnostic: d, read_workers: readBudget.inspect(),
@@ -116,6 +141,7 @@ export async function createMcpDecisionRuntime({ runtime, ui, appOnlyMediationQu
     open: (input, result, host) => session.open(input, result, host), read: (input, signal, host) => session.read(input, signal, host),
     action: (input, host) => session.action(input, host), close: () => session.close() });
   return Object.freeze({ ...protocol,
+    observeOutcome: (name, input, result) => runtime.observeOutcome?.(name, input, result) ?? false,
     async postprocessToolResult(name, input, result, { uiSupported, client } = {}) {
       if (name === 'agdf_inspect' && input.operation === 'native-qualification' && result.report?.available) {
         return { ...result, report: { ...result.report, ui_rendering_support: uiSupported ? 'supported' : 'unsupported',

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/mcp-lifecycle/package.js

@@ -27,6 +27,7 @@ import {
 import { defaultNpmInstallRoot, npmInvocation } from "../npm-invocation.js";
 import { renameSyncWithRetry } from "#agdf-core/fs-swap.js";
 import { fsyncDirectory, withOwnedFileLock } from '#agdf-core/owned-file-lock.js';
+import { createPreparedCallJournal } from './prepared-call-journal.js';
 
 const CLAIMS = '.agdf-executable-claims';
 
@@ -440,6 +441,12 @@ export function createMcpGenerationPublisher(base, { publicationDeadline = Infin
   if (canonical !== base.publisher_root || !base.immutable) throw Error('runtime_publication_unowned');
   return Object.freeze({
     initial: base,
+    // Only a freshly owned publisher supplies persistent transport storage.
+    // This is lazy: constructing/discovering the SDK creates no journal files.
+    preparedCallStore({ surface }) {
+      return createPreparedCallJournal({ publisherRoot: canonical, identity: { surface, version: base.version,
+        server_digest: base.digest, dispatcher_digest: base.dispatcherDigest, sdk_digest: base.sdkDigest } });
+    },
     resolve(candidate) {
       const keys = ['schema_version', 'publication_id', 'version', 'server_digest', 'dispatcher_digest', 'sdk_digest'];
       if (!candidate || Object.keys(candidate).sort().join() !== keys.sort().join()

package/generated/plugins/copilot/agdf/runtime/create-agdf/lib/mcp-lifecycle/plugin-runtime.js

@@ -1,10 +1,11 @@
 import { execFileSync, spawn, fork } from "node:child_process";
-import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync, rmdirSync } from "node:fs";
+import { cpSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync, rmdirSync, unlinkSync } from "node:fs";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import process from "node:process";
 import { createHash, randomUUID } from 'node:crypto';
 import { digestDirectory, digestPluginMcpDispatcherSource, mcpDispatcherRuntimeEntries, mcpDispatcherPackageExports } from "#agdf-core/runtime/plugin-provenance.js";
 import { acquireMcpExecutableClaim, inspectMcpServerPackage, mcpPackageConstants, mcpRuntimeRetirementState, prepareMcpServerPackage, createMcpRuntimeRetirementTransaction } from "./package.js";
+import { inspectPreparedCallJournals, retirePreparedCallJournals } from './prepared-call-journal.js';
 
 // Plugin-local AGDF MCP runtime shared by the hosts whose runtime plugin declares the server itself:
 // Claude Code passes ${CLAUDE_PLUGIN_DATA}, which it deletes on uninstall; Codex receives an absolute
@@ -15,6 +16,12 @@ const SDK_PACKAGE_SPEC = "@modelcontextprotocol/server@2.0.0";
 // the shipped digest; the override deliberately restores the unverified install and is recorded.
 export const SDK_BUNDLE = Object.freeze({ manifest: "package.json", lock: "package-lock.json", expected: "expected-sdk.json" });
 export const SDK_OVERRIDE_ENV = "AGDF_MCP_ALLOW_UNVERIFIED_SDK";
+// The journal's data-root variable (COMPANION_DATA_ROOT_ENV of core companion/journal.js), kept as a
+// literal so the launcher stays free of the journal module; the journal test asserts both agree.
+export const COMPANION_DATA_ROOT_ENV = "AGDF_COMPANION_DATA_ROOT";
+// The journal's directory and its two files below the data root (JOURNAL_DIRECTORY, JOURNAL_FILE and
+// JOURNAL_ROTATED_FILE of core companion/journal.js), owned and removed with the runtime (SD SDD-006).
+export const COMPANION_JOURNAL = Object.freeze({ directory: "companion", files: Object.freeze(["events.jsonl", "events.1.jsonl"]) });
 export const SDK_VERIFICATION = Object.freeze({ verified: "verified", override: "unverified_override" });
 
 function readJson(path) {
@@ -249,6 +256,10 @@ export async function launchPluginMcpServer({
     return null;
   }
   const { surface, dataRoot, cockpitDir, cockpitMode, prepareOnly } = invocation;
+  // Companion events (companion core SDD-006): the facade and its generations journal final tool
+  // results below the data root this launcher received; the variable reaches them with the facade's
+  // environment only. Preparation keeps the launcher's own environment.
+  const facadeEnv = typeof dataRoot === 'string' && dataRoot ? { ...env, [COMPANION_DATA_ROOT_ENV]: resolve(dataRoot) } : env;
   const publicationDeadline = performance.now() + CONCURRENT_PUBLICATION_WAIT_MS;
   let runtime, waitingOwner;
   try {
@@ -256,7 +267,7 @@ export async function launchPluginMcpServer({
     // preparation. It cannot claim or start a facade until the private message
     // carries the successfully verified publication.
     if (!prepareOnly && !startFacade && acquireClaim === acquireMcpExecutableClaim && ensure === ensurePluginMcpRuntime)
-      waitingOwner = startFacadeOwner({ surface, cockpitDir, cockpitMode, pluginRoot, env, publicationDeadline });
+      waitingOwner = startFacadeOwner({ surface, cockpitDir, cockpitMode, pluginRoot, env: facadeEnv, publicationDeadline });
     // Reject a damaged installed dispatcher before publication, claim acquisition
     // or SDK execution. Its downstream resource context cannot qualify a facade;
     // starting one first would correctly retain its unconfirmed executable use.
@@ -285,7 +296,7 @@ export async function launchPluginMcpServer({
   // executable before fork and releases only after orderly teardown AND exit.
   if (!startFacade && acquireClaim === acquireMcpExecutableClaim) {
     try {
-      const owner = waitingOwner ?? startFacadeOwner({ runtime, surface, cockpitDir, cockpitMode, pluginRoot, env, publicationDeadline });
+      const owner = waitingOwner ?? startFacadeOwner({ runtime, surface, cockpitDir, cockpitMode, pluginRoot, env: facadeEnv, publicationDeadline });
       waitingOwner?.activate(runtime);
       return await owner.settled;
     }
@@ -299,7 +310,7 @@ export async function launchPluginMcpServer({
       ? error.message : 'AGDF_MCP_EXECUTABLE_CLAIM_INVALID';
     stderr.write(`${launcherFailureLine(code)}\n`); process.exitCode = 1; return null;
   }
-  try { return await (startFacade ?? supervisePluginMcpFacade)({ runtime, surface, cockpitDir, cockpitMode, pluginRoot, env, publicationDeadline, claim }); }
+  try { return await (startFacade ?? supervisePluginMcpFacade)({ runtime, surface, cockpitDir, cockpitMode, pluginRoot, env: facadeEnv, publicationDeadline, claim }); }
   catch (error) {
     const code = Object.hasOwn(LAUNCHER_FAILURES, error?.message) ? error.message : 'AGDF_MCP_PLUGIN_RUNTIME_FAILED';
     stderr.write(`${launcherFailureLine(code, 'facade')}\n`); process.exitCode = 1; return null;
@@ -376,12 +387,18 @@ export const claudePluginMcpConstants = Object.freeze({ sdkPackageSpec: SDK_PACK
 
 // Codex keeps the plugin-local MCP runtime in an AGDF-owned data root because it passes no plugin data
 // directory; `codex plugin remove` cannot delete it. `dataRoot` is the launcher data root (--data);
-// uninstall removes it only when it holds nothing but owned runtimes and abandoned stages under mcp/.
+// uninstall removes it only when it holds nothing but owned runtimes and abandoned stages under mcp/
+// and the companion journal (a plain directory holding only its own regular files).
+function ownedCompanionJournal(dataRoot) {
+  const directory = join(dataRoot, COMPANION_JOURNAL.directory), stats = lstatSync(directory);
+  if (!stats.isDirectory() || stats.isSymbolicLink()) return false;
+  return readdirSync(directory).every(name => COMPANION_JOURNAL.files.includes(name) && lstatSync(join(directory, name)).isFile());
+}
 export function inspectPluginMcpDataRoot(dataRoot) {
   if (!existsSync(dataRoot)) return "absent";
   try {
     if (!lstatSync(dataRoot).isDirectory() || lstatSync(dataRoot).isSymbolicLink()) return "foreign";
-    if (readdirSync(dataRoot).some((name) => name !== "mcp")) return "foreign";
+    if (readdirSync(dataRoot).some((name) => name !== "mcp" && !(name === COMPANION_JOURNAL.directory && ownedCompanionJournal(dataRoot)))) return "foreign";
     const mcpDataRoot = join(realpathSync(dataRoot), "mcp");
     if (!existsSync(mcpDataRoot)) return "owned";
     if (!lstatSync(mcpDataRoot).isDirectory() || lstatSync(mcpDataRoot).isSymbolicLink()) return "foreign";
@@ -390,6 +407,10 @@ export function inspectPluginMcpDataRoot(dataRoot) {
       const path = join(mcpDataRoot, name);
       const stats = lstatSync(path);
       if (!stats.isDirectory() || stats.isSymbolicLink()) return "foreign";
+      if (name === 'prepared-calls') {
+        if (inspectPreparedCallJournals(mcpDataRoot) !== 'owned') return 'foreign';
+        continue;
+      }
       if (name !== 'generations') {
         if (!ownedRoot(path) && !name.startsWith('.stage-')) return 'foreign';
         protectedFiles = true; continue;
@@ -430,7 +451,14 @@ export function retirePluginMcpDataRoot(dataRoot, revalidate = () => {}) {
       rmdirSync(publication);
     }
     if (existsSync(generations)) rmdirSync(generations);
+    retirePreparedCallJournals(mcp);
     if (existsSync(mcp)) rmdirSync(mcp);
+    const journal = join(dataRoot, COMPANION_JOURNAL.directory);
+    if (existsSync(journal)) {
+      revalidate();
+      for (const name of COMPANION_JOURNAL.files) if (existsSync(join(journal, name))) unlinkSync(join(journal, name));
+      rmdirSync(journal);
+    }
     revalidate(); rmdirSync(dataRoot);
     return true;
   } catch (error) {