@astrosheep/keiyaku 1.0.2 → 2.8.1

package/build/agents/call-terms_v2.js

@@ -54,8 +54,12 @@ export function buildCallTermsV2(snapshot, prompt, cwd, options) {
                     ? { config: snapshot.provider.config }
                     : {}),
                 ...(snapshot.provider.executable !== undefined ? { executable: snapshot.provider.executable } : {}),
-                sandboxPolicy: snapshot.provider.sandboxPolicy,
-                approvalPolicy: snapshot.provider.approvalPolicy,
+                ...(snapshot.provider.sandboxPolicy !== undefined
+                    ? { sandboxPolicy: snapshot.provider.sandboxPolicy }
+                    : {}),
+                ...(snapshot.provider.approvalPolicy !== undefined
+                    ? { approvalPolicy: snapshot.provider.approvalPolicy }
+                    : {}),
                 developerInstructions: body || undefined,
                 onCheckpoint() { },
             };

package/build/agents/harness/index.js

@@ -202,7 +202,11 @@ async function settleProjection(shared) {
                 ? launchTellFence
                 : (() => { throw new FlowError("INTERNAL_STATE", "generation launch has an invalid tellFence"); })();
         const launchSnapshot = shared.terms.projectionDir && shared.terms.projectionExecutionId
-            ? snapshotReplayPrompt(shared.terms.projectionDir, shared.terms.prompt, tellFence, shared.terms.projectionExecutionId)
+            ? snapshotReplayPrompt(shared.terms.projectionDir, shared.terms.prompt, tellFence, shared.terms.projectionExecutionId, 
+            // Session resume already holds launch history. Only fenced tells are
+            // new operator input; re-blasting the original prompt reasserts stale
+            // allowlists and breaks resting continuation.
+            { sessionContinuation: shared.reviveTerms !== undefined })
             : undefined;
         const launchTerms = launchSnapshot
             ? shared.terms.provider === "codex-sdk" && launchSnapshot.effort

package/build/agents/harness/pump.js

@@ -1,14 +1,31 @@
 import { claimAllInbox, claimFencedTells, listTellIds, markTellSubmitted, markTellConsumed, readTellSubmitted, readTellOriginal, isTellCausallyConsumed, appendGenerationEvent, } from "../../core/projection-core.js";
 import { prepareAgentEventForPersistence, } from "./execution-handle.js";
+const OPERATOR_PROMPT_MARKER = "[Operator prompt]\n";
+function frameTellBodies(projectionDirectory, tellIds) {
+    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
+    const frames = originals
+        .map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`)
+        .join("\n\n");
+    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
+    return { frames, ...(effort ? { effort } : {}) };
+}
+function operatorBodyForContinuation(prompt, tellFrames, sessionContinuation) {
+    if (!sessionContinuation)
+        return `${prompt}\n\n${tellFrames}`;
+    const markerAt = prompt.indexOf(OPERATOR_PROMPT_MARKER);
+    if (markerAt >= 0) {
+        return `${prompt.slice(0, markerAt + OPERATOR_PROMPT_MARKER.length)}${tellFrames}`;
+    }
+    return tellFrames;
+}
 /** Tier-2 boundary snapshot. No tells leaves prompt byte-identical. */
-export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId) {
+export function snapshotReplayPrompt(projectionDirectory, prompt, tellFence, executionId, options = {}) {
     const tellIds = claimFencedTells(projectionDirectory, tellFence, executionId);
     if (tellIds.length === 0)
         return { prompt, tellIds };
-    const originals = tellIds.map((tellId) => readTellOriginal(projectionDirectory, "inflight", tellId));
-    const frames = originals.map((original, index) => `--- tell ${tellIds[index]} ---\n${original.text}`);
-    const effort = originals.reduce((value, original) => original.effort ?? value, undefined);
-    return { prompt: `${prompt}\n\n${frames.join("\n\n")}`, tellIds, ...(effort ? { effort } : {}) };
+    const { frames, effort } = frameTellBodies(projectionDirectory, tellIds);
+    const nextPrompt = operatorBodyForContinuation(prompt, frames, options.sessionContinuation === true);
+    return { prompt: nextPrompt, tellIds, ...(effort ? { effort } : {}) };
 }
 /** Tier-2 has no steer acknowledgement: actual driver start is its ordinal-zero submission point. */
 export function markReplayStarted(projectionDirectory, executionId, tellIds) {

package/build/agents/launch-snapshot_v2.js

@@ -1,6 +1,7 @@
 import * as path from "node:path";
+import { nativePolicyOwnership } from "../config/provider-policy-ownership.js";
 import { FlowError } from "../flow-error.js";
-import { buildCodexAppServerWorkspaceWriteSandboxPolicy, } from "./providers/codex-app-server.js";
+import { buildCodexAppServerWorkspaceWriteSandboxPolicy, configOwnsApprovalPolicy, configOwnsSandboxPolicy, } from "./providers/codex-app-server.js";
 const ACCESS_VALUES = new Set(["read", "write", "auto"]);
 const NETWORK_VALUES = new Set(["disabled", "enabled"]);
 const WEB_SEARCH_VALUES = new Set(["disabled", "cached", "live"]);
@@ -198,16 +199,15 @@ function parseProvider(value) {
         }
         case "codex-app-server": {
             exactKeys(provider, ["name", "source", "kind", "executable", "profile", "config", "model", "effort", "sandboxPolicy", "approvalPolicy"], "provider");
-            if (!("sandboxPolicy" in provider))
-                throw snapshotError("provider.sandboxPolicy", "is required");
-            if (provider.approvalPolicy !== "never")
+            if ("approvalPolicy" in provider && provider.approvalPolicy !== "never")
                 throw snapshotError("provider.approvalPolicy", "must equal 'never'");
             const executable = optionalString(provider, "executable", "provider");
             const profile = optionalString(provider, "profile", "provider");
             const config = optionalJsonObject(provider, "config");
             const model = optionalString(provider, "model", "provider");
             const effort = optionalString(provider, "effort", "provider");
-            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), sandboxPolicy: parseSandboxPolicy(provider.sandboxPolicy), approvalPolicy: "never" });
+            const sandboxPolicy = "sandboxPolicy" in provider ? parseSandboxPolicy(provider.sandboxPolicy) : undefined;
+            return Object.freeze({ ...common, kind, ...(executable !== undefined ? { executable } : {}), ...(profile !== undefined ? { profile } : {}), ...(config !== undefined ? { config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(sandboxPolicy !== undefined ? { sandboxPolicy } : {}), ...(provider.approvalPolicy === "never" ? { approvalPolicy: "never" } : {}) });
         }
         case "claude-agent-sdk": {
             exactKeys(provider, ["name", "source", "kind", "executable", "model", "effort", "settingSources", "permissionMode", "allowDangerouslySkipPermissions", "disallowedTools"], "provider");
@@ -295,9 +295,14 @@ export function resolveAkumaLaunchSnapshot(selected, input) {
     switch (instance.kind) {
         case "codex-sdk": {
             const threadOptions = { ...(instance.threadOptions ?? {}) };
-            threadOptions.sandboxMode = selected.profile.access === "read" ? "read-only" : selected.profile.access === "auto" ? "danger-full-access" : "workspace-write";
-            threadOptions.networkAccessEnabled = selected.profile.network === "enabled";
-            threadOptions.webSearchMode = "disabled";
+            const ownership = nativePolicyOwnership(selected.profile.provider, instance);
+            if (ownership.access.length === 0) {
+                threadOptions.sandboxMode = selected.profile.access === "read" ? "read-only" : selected.profile.access === "auto" ? "danger-full-access" : "workspace-write";
+            }
+            if (ownership.network.length === 0)
+                threadOptions.networkAccessEnabled = selected.profile.network === "enabled";
+            if (ownership.webSearch.length === 0)
+                threadOptions.webSearchMode = selected.profile.webSearch ?? "disabled";
             if (model !== undefined)
                 threadOptions.model = model;
             if (effort !== undefined)
@@ -310,7 +315,7 @@ export function resolveAkumaLaunchSnapshot(selected, input) {
         case "codex-app-server": {
             const roots = [path.resolve(input.executionCwd), ...(instance.writableRoots ?? []).map((root) => path.resolve(input.projectRoot, root))];
             const writableRoots = [...new Set(roots)];
-            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({ writableRoots, networkAccess: selected.profile.network === "enabled" }), approvalPolicy: "never" };
+            provider = { ...common, ...(instance.executable !== undefined ? { executable: instance.executable } : {}), ...(instance.profile !== undefined ? { profile: instance.profile } : {}), ...(instance.config !== undefined ? { config: instance.config } : {}), ...(model !== undefined ? { model } : {}), ...(effort !== undefined ? { effort } : {}), ...(!configOwnsSandboxPolicy(instance.config) ? { sandboxPolicy: buildCodexAppServerWorkspaceWriteSandboxPolicy({ writableRoots, networkAccess: selected.profile.network === "enabled" }) } : {}), ...(!configOwnsApprovalPolicy(instance.config) ? { approvalPolicy: "never" } : {}) };
             break;
         }
         case "claude-agent-sdk": {

package/build/agents/selector_v2.js

@@ -1,6 +1,7 @@
 import { getConfig } from "../config/env.js";
 import { loadAkumaCatalogV2, } from "../config/akuma-loader_v2.js";
 import { assertSettingsKnobUsable, loadKeiyakuSettings, resolveDefaultAgentName, } from "../config/settings.js";
+import { nativePolicyOwnership } from "../config/provider-policy-ownership.js";
 import { FlowError } from "../flow-error.js";
 const ACCESS_VALUES = ["read", "write", "auto"];
 const NETWORK_VALUES = ["disabled", "enabled"];
@@ -8,7 +9,7 @@ const SUPPORTED_EXPLICIT = {
     "codex-sdk": {
         access: new Set(ACCESS_VALUES),
         network: new Set(NETWORK_VALUES),
-        webSearch: new Set(["disabled"]),
+        webSearch: new Set(["disabled", "cached", "live"]),
     },
     "codex-app-server": {
         access: new Set(["write"]),
@@ -56,6 +57,15 @@ export function assertPortablePolicySupported(adapter, policy) {
         }
     }
 }
+function assertPortablePolicyOwnership(akumaName, instanceName, instance, policy) {
+    const ownership = nativePolicyOwnership(instanceName, instance);
+    for (const axis of ["access", "network", "webSearch"]) {
+        if (policy[axis] === undefined || ownership[axis].length === 0)
+            continue;
+        const settingsPaths = ownership[axis].map((owner) => `settings.${owner.path}`).join(", ");
+        throw new FlowError("INVALID_SETTINGS", `Akuma '${akumaName}' declares frontmatter.${axis}, but provider instance '${instanceName}' also owns that policy at ${settingsPaths}. Remove one declaration.`);
+    }
+}
 function isValidAkumaCandidate(candidate) {
     return !("reason" in candidate && candidate.reason !== undefined) && candidate.profile !== undefined && candidate.body !== undefined;
 }
@@ -96,11 +106,13 @@ export async function selectSubagentV2(agentName, cwd) {
     }
     const providerInstance = providerCandidate.instance;
     const adapter = providerInstance.kind;
-    assertPortablePolicySupported(adapter, {
+    const portablePolicy = {
         ...(candidate.profile.access !== undefined ? { access: candidate.profile.access } : {}),
         ...(candidate.profile.network !== undefined ? { network: candidate.profile.network } : {}),
         ...(candidate.profile.webSearch !== undefined ? { webSearch: candidate.profile.webSearch } : {}),
-    });
+    };
+    assertPortablePolicyOwnership(selected, instanceName, providerInstance, portablePolicy);
+    assertPortablePolicySupported(adapter, portablePolicy);
     const profile = freezeResolvedProfile({
         provider: instanceName,
         adapter,

package/build/cli/commands/akuma.js

@@ -1,5 +1,6 @@
 import { resolveDefaultAgentName, resolveReviewerAgentName, } from "../../config/settings.js";
 import { FlowError } from "../../flow-error.js";
+import { nativePolicyOwnership } from "../../config/provider-policy-ownership.js";
 function formatRoleMarkers(settings, name) {
     const markers = [];
     if (name === resolveDefaultAgentName(settings))
@@ -81,6 +82,25 @@ function appendPromptPreview(lines, body) {
     lines.push(...promptLines.slice(0, 8).map((line) => `  ${line}`));
     lines.push(`(${promptLines.length} lines total)`);
 }
+function appendPolicyLines(lines, resolved) {
+    const ownership = nativePolicyOwnership(resolved.instanceName, resolved.instance);
+    const axes = ["access", "network", "webSearch"];
+    for (const axis of axes) {
+        const value = resolved.profile[axis];
+        if (value !== undefined) {
+            lines.push(`${axis}: ${value} [source: akuma frontmatter.${axis}]`);
+            continue;
+        }
+        const owners = ownership[axis];
+        if (owners.length === 0)
+            continue;
+        if (axis === "webSearch") {
+            lines.push(`webSearch: ${JSON.stringify(owners[0].value)} [source: instance config ${owners[0].path}]`);
+            continue;
+        }
+        lines.push(`${axis}: native [source: instance config ${owners.map((owner) => owner.path).join(", ")}]`);
+    }
+}
 function chooseCallHintName(validNames, settings) {
     if (validNames.length === 0)
         return null;
@@ -149,9 +169,7 @@ export function renderAkumaShow(catalog, providerInstances, settings, name) {
     appendOptionalLine(lines, "model", resolved.profile.model);
     appendOptionalLine(lines, "effort", resolved.profile.effort);
     appendOptionalLine(lines, "effortOptions", resolved.profile.effortOptions);
-    appendOptionalLine(lines, "access", resolved.profile.access);
-    appendOptionalLine(lines, "network", resolved.profile.network);
-    appendOptionalLine(lines, "webSearch", resolved.profile.webSearch);
+    appendPolicyLines(lines, resolved);
     appendPromptPreview(lines, resolved.body);
     return lines.join("\n");
 }

package/build/cli/completion.js

@@ -35,7 +35,10 @@ export async function renderCompletionCandidates(input) {
     if (word.startsWith("@")) {
         return (await contractAddressCandidates(input.cwd, word)).join("\n");
     }
-    if (input.previous === "call" || input.previous === "show") {
+    if (input.previous === "call") {
+        return filterPrefix([...(await akumaCandidates(input.cwd, word)), "--alias"], word).join("\n");
+    }
+    if (input.previous === "show") {
         return (await akumaCandidates(input.cwd, word)).join("\n");
     }
     if (input.previous === "akuma") {

package/build/cli/flags.js

@@ -34,7 +34,12 @@ export const FLAG_SPECS = {
     projection: {
         kind: "value",
         placeholder: "ID",
-        description: "Akuma projection id.",
+        description: "Akuma projection address.",
+    },
+    alias: {
+        kind: "value",
+        placeholder: "WORD",
+        description: "Move a projection alias to this newly launched call.",
     },
     timeout: {
         kind: "value",
@@ -108,6 +113,10 @@ export const FLAG_SPECS = {
         placeholder: "REF",
         description: "Filter target-keyed status facts by branch name or full refs/heads/<name>.",
     },
+    all: {
+        kind: "boolean",
+        description: "Show all retained Akuma projections while preserving status priority order.",
+    },
 };
 export const CONTROL_FLAGS = new Set(Object.keys(FLAG_SPECS));
 export const VALUE_FLAGS = new Set(Object.entries(FLAG_SPECS)

package/build/cli/help.js

@@ -10,9 +10,9 @@ export const CLI_COMMAND_METADATA = {
         input: ["# <arc title>", "", "## Objective", "<what this arc should accomplish>", "", "## Brief", "<scope, constraints, relevant files, instructions>"],
         notes: ["An empty seal is valid.", "The command does not create delivery commits."],
     }),
-    call: command("call", "Start an Akuma helper session", ["keiyaku call NAME [prompt|-]", "keiyaku call NAME --detach [prompt|-]", "keiyaku @addr call NAME [prompt|-]", "keiyaku call NAME --contract ADDR [prompt|-]"], "none", ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach"], "Run a scoped helper task."),
+    call: command("call", "Start an Akuma helper session", ["keiyaku call NAME [--alias WORD] [prompt|-]", "keiyaku call NAME --detach [prompt|-]", "keiyaku @addr call NAME [prompt|-]", "keiyaku call NAME --contract ADDR [prompt|-]"], "none", ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias"], "Run a scoped helper task."),
     revive: command("revive", "Revive an Akuma helper session", ["keiyaku revive ARTIFACT_ID"], "none", ["cwd", "repo", "model", "effort"], "Continue a persisted helper session."),
-    wait: command("wait", "Wait for an akuma projection", ["keiyaku wait <short-id> [--timeout DURATION]", "keiyaku @addr wait <short-id> [--timeout DURATION]"], "none", ["cwd", "repo", "contract", "timeout"], "Read an akuma projection until its outcome is available, or show a timeout snapshot."),
+    wait: command("wait", "Wait for an akuma projection", ["keiyaku wait <projection-address> [--timeout DURATION]", "keiyaku @addr wait <projection-address> [--timeout DURATION]"], "none", ["cwd", "repo", "contract", "timeout"], "Read an akuma projection until its outcome is available, or show a timeout snapshot."),
     tell: command("tell", "Send intent to a projection mailbox", ["keiyaku tell [--effort LEVEL] PROJECTION MESSAGE", "keiyaku @addr tell [--effort LEVEL] PROJECTION MESSAGE"], "none", ["cwd", "repo", "contract", "effort"], "Write intent to the mailbox and wake only when eligible."),
     log: command("log", "Render a contract ledger", ["keiyaku log [-C|--cwd DIR] [--repo DIR] [--contract ADDR]", "keiyaku @addr log [-C|--cwd DIR] [--repo DIR]"], "none", ["cwd", "repo", "contract"], "Read a contract ledger."),
     akuma: command("akuma", "Inspect Akuma profiles", ["keiyaku akuma list|show"], "none", [], "Inspect configured helper profiles.", {
@@ -31,7 +31,7 @@ export const CLI_COMMAND_METADATA = {
     forfeit: command("forfeit", "Forfeit an addressed contract", ["keiyaku forfeit [-C|--cwd DIR] [--repo DIR] [--contract ADDR] [--reason TEXT]", "keiyaku @addr forfeit [-C|--cwd DIR] [--repo DIR] [--reason TEXT]"], "none", ["cwd", "repo", "contract", "reason"], "Record an abandoned contract without sealing it."),
     guide: command("guide", "Print the Keiyaku guide", ["keiyaku guide"], "none", [], "Print workflow guidance."),
     completion: command("completion", "Print shell completion", ["keiyaku completion [--shell bash|zsh]"], "none", ["cwd", "repo", "shell", "word", "previous", "complete"], "Print command and address candidates."),
-    status: command("status", "Show the Kanshi board", ["keiyaku status [-C|--cwd DIR] [--repo DIR] [--target REF]"], "none", ["cwd", "repo", "target"], "Read contract, queue, and projection facts without mutation."),
+    status: command("status", "Show the Kanshi board", ["keiyaku status [-C|--cwd DIR] [--repo DIR] [--target REF] [--all]"], "none", ["cwd", "repo", "target", "all"], "Read contract, queue, and projection facts without mutation."),
     "dump-env": command("dump-env", "Print the environment template", ["keiyaku dump-env"], "none", [], "Print supported environment keys.", { notes: ["Keiyaku loads <KEIYAKU_HOME>/.env, then .keiyaku/.env; process environment values win."] }),
 };
 function indent(lines) {

package/build/cli/index.js

@@ -6,7 +6,7 @@ import { amendKeiyaku } from "../core/amend.js";
 import { arcKeiyaku, buildArcInput } from "../core/arc.js";
 import { bindContract } from "../core/bind.js";
 import { buildAmendInput, defaultActorClock } from "../core/command-io.js";
-import { AddressResolutionError, buildResolutionAttempt, resolveContractAddress, withResolvedAddress, } from "../core/addressing.js";
+import { AddressResolutionError, buildArtifactResolutionAttempt, buildResolutionAttempt, resolveContractAddress, withResolvedAddress, } from "../core/addressing.js";
 import { forfeitContractCommand } from "../core/forfeit.js";
 import { readContractLog } from "../core/log.js";
 import { buildPetitionClaimInput } from "../core/petition.js";
@@ -14,6 +14,7 @@ import { petitionKeiyaku } from "../core/petition-run.js";
 import { renewKeiyaku } from "../core/renew.js";
 import { normalizeTargetRef, readKanshiBoard } from "../core/status.js";
 import { runCallAndPersist } from "../core/call-persist.js";
+import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { locateResponseArtifact } from "../core/transcripts.js";
 import { renderEnvExample } from "../config/env-keys.js";
 import { assertSettingsKnobUsable, loadKeiyakuSettings } from "../config/settings.js";
@@ -41,6 +42,7 @@ import { prependAddressReceipt, renderResolvedAddressReceipt } from "./render/ad
 import { installOfficialSkills } from "./skills-install.js";
 import { isGitRepo } from "../git/branches.js";
 import { stableRepoRoot } from "../core/worktree-path.js";
+import { assertProjectionAlias } from "../core/projection-alias.js";
 const CALL_INPUT_HINTS = [
     "Call input can be a prompt argument, `-` to read stdin, or omitted to read stdin.",
     "Use `keiyaku call NAME \"prompt\"`, `keiyaku call NAME - < prompt.md`, or `keiyaku revive ARTIFACT_ID`.",
@@ -79,6 +81,7 @@ function buildCallInput(content, flags, mode = "call") {
         incognito: flags.incognito,
         bare: flags.bare,
         detach: flags.detach,
+        ...(mode === "call" && flags.alias !== undefined ? { alias: assertProjectionAlias(flags.alias) } : {}),
     };
 }
 function revivePrompt(stdin) {
@@ -96,7 +99,7 @@ async function repositoryDirectory(flags) {
         if (flags.contractId) {
             const asTyped = flags.contractAddressSource === "at-address"
                 ? `@${flags.contractId}`
-                : flags.contractId;
+                : `--contract ${flags.contractId}`;
             throw new AddressResolutionError("EMPTY_PARAM", `${asTyped} is a commission address, but ${candidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
                 repo: { kind: "user" },
                 workdir: effectiveDirectory(flags),
@@ -142,13 +145,13 @@ const CLI_COMMAND_SPECS = {
             ...(!flags.detach
                 ? {
                     onLaunch: ({ address, projection }) => {
-                        process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id)}\n`);
+                        process.stdout.write(`${renderAdoptedLaunchReceipt(address, projection.id, projection.alias, projection.previousAliasTarget)}\n`);
                     },
                 }
                 : {}),
         });
         if (outcome.result.foregroundWait && outcome.result.projection) {
-            return buildWaitResponse(outcome.result.projection.id, outcome.result.foregroundWait);
+            return buildWaitResponse(outcome.result.projection.id, outcome.result.foregroundWait, { alias: outcome.result.projection.alias });
         }
         return buildCallResponse(outcome.result, {
             responsePath: outcome.responsePath,
@@ -160,8 +163,20 @@ const CLI_COMMAND_SPECS = {
         const cwd = effectiveDirectory(flags);
         const artifactCwd = await projectDirectory(flags);
         const artifactId = positional[0];
-        const responseStoreCwd = await isGitRepo(artifactCwd) ? await stableRepoRoot(artifactCwd) : await fs.realpath(artifactCwd);
-        const artifact = await locateResponseArtifact(responseStoreCwd, artifactId);
+        const isRepo = await isGitRepo(artifactCwd);
+        const responseStoreCwd = isRepo ? await stableRepoRoot(artifactCwd) : await fs.realpath(artifactCwd);
+        const artifact = await locateResponseArtifact({
+            cwd: responseStoreCwd,
+            artifactId,
+            attempt: buildArtifactResolutionAttempt({
+                repo: isRepo
+                    ? { kind: "repository", stableRoot: responseStoreCwd }
+                    : { kind: "user" },
+                workdir: cwd,
+                supplied: artifactId,
+                inference: ["response artifact identity lookup"],
+            }),
+        });
         let executionCwd;
         let repo;
         if (artifact.provenance.authority.kind === "repository") {
@@ -186,20 +201,30 @@ const CLI_COMMAND_SPECS = {
         const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
         const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
         const operation = async () => {
-            const projectionId = resolveProjectionAddress(cwd, positional[0], address?.binding.commissionId);
-            return prependAddressReceipt(buildWaitResponse(projectionId, await waitForProjection({ projectionDirectory: projectionDir(cwd, projectionId), timeoutMs: flags.timeoutMs, signal })), address, { projectionId });
+            const projection = await resolveProjectionAddress({
+                cwd,
+                address: positional[0],
+                scope: address,
+                verb: "wait",
+            });
+            return prependAddressReceipt(buildWaitResponse(projection.id, await waitForProjection({ projectionDirectory: projectionDir(cwd, projection.id), timeoutMs: flags.timeoutMs, signal }), { alias: projection.alias }), address, { projectionId: projection.id, projectionAlias: projection.alias });
         };
         return address ? await withResolvedAddress(address, operation) : await operation();
     }),
     tell: commandSpec("tell", async (_stdin, flags, _signal, positional) => {
         const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
-        const [prefix, message] = positional;
-        if (!prefix || !message)
-            throw new FlowError("EMPTY_PARAM", "tell requires a projection and message");
+        const [projectionAddress, message] = positional;
+        if (!projectionAddress || !message)
+            throw new FlowError("EMPTY_PARAM", "tell requires a projection address and message");
         const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
         const operation = async () => {
-            const projectionId = resolveProjectionAddress(cwd, prefix, address?.binding.commissionId);
-            const directory = projectionDir(cwd, projectionId);
+            const projection = await resolveProjectionAddress({
+                cwd,
+                address: projectionAddress,
+                scope: address,
+                verb: "tell",
+            });
+            const directory = projectionDir(cwd, projection.id);
             assertTellEffortSupported(directory, flags.effort);
             // Mailbox first: do not inspect phase before this immutable write.
             writeInboxTell(directory, message, Date.now(), { effort: flags.effort });
@@ -232,6 +257,9 @@ const CLI_COMMAND_SPECS = {
         if (!name) {
             throw new FlowError("EMPTY_PARAM", "akuma show requires an Akuma name");
         }
+        if (isResponseArtifactId(name)) {
+            throw new FlowError("EMPTY_PARAM", `artifact ${name} is a response artifact; akuma show expects an Akuma profile name`);
+        }
         const cwd = await projectDirectory(flags);
         const loaded = await loadKeiyakuSettings(cwd);
         // Role markers need settings pointers; catalog consumers keep legacy agents disease actionable.
@@ -288,7 +316,10 @@ const CLI_COMMAND_SPECS = {
         // honors --repo as a repository coordinate when the operator names one.
         const cwd = await projectDirectory(flags);
         const target = flags.target === undefined ? undefined : normalizeTargetRef(flags.target);
-        return textResponse(renderStatusBoard(await readKanshiBoard(cwd, Date.now(), target === undefined ? undefined : { target })));
+        return textResponse(renderStatusBoard(await readKanshiBoard(cwd, Date.now(), {
+            ...(target === undefined ? {} : { target }),
+            showAllProjections: flags.all === true,
+        })));
     }),
     "dump-env": commandSpec("dump-env", async () => textResponse(renderEnvExample())),
 };

package/build/cli/parse.js

@@ -1,5 +1,6 @@
 import { FlowError } from "../flow-error.js";
 import { agentNameSchema } from "../config/settings.js";
+import { isResponseArtifactId } from "../core/response-artifact-id.js";
 import { BOOLEAN_FLAGS, CONTROL_FLAGS, HELP_FLAGS, SHORT_FLAG_ALIASES, VALUE_FLAGS, } from "./flags.js";
 /** Commands that may carry an explicit commission selector (@ or --contract). */
 const COMMISSION_SELECTOR_COMMANDS = new Set([
@@ -40,7 +41,7 @@ const COMMAND_FLAGS = {
     // contract is parseable on bind only so the mouth can reject it with bind-specific copy.
     bind: ["cwd", "repo", "contract", "after", "exclusive", "draft-only"],
     arc: ["cwd", "repo", "contract", "waive"],
-    call: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach"],
+    call: ["cwd", "repo", "contract", "akuma", "model", "effort", "incognito", "bare", "detach", "alias"],
     revive: ["cwd", "repo", "model", "effort"],
     wait: ["cwd", "repo", "contract", "timeout"],
     tell: ["cwd", "repo", "contract", "effort"],
@@ -57,7 +58,7 @@ const COMMAND_FLAGS = {
     forfeit: ["cwd", "repo", "contract", "reason"],
     guide: [],
     completion: ["cwd", "repo", "shell", "word", "previous", "complete"],
-    status: ["cwd", "repo", "target"],
+    status: ["cwd", "repo", "target", "all"],
     "dump-env": [],
 };
 const STDIN_COMMANDS = new Set(["bind", "arc", "amend"]);
@@ -95,7 +96,7 @@ export function commandPositionalRange(command) {
     if (command === "revive")
         return { min: 1, max: 1, label: "<artifact-id>" };
     if (command === "wait")
-        return { min: 1, max: 1, label: "<short-id>" };
+        return { min: 1, max: 1, label: "<projection-address>" };
     if (command === "tell")
         return { min: 2, max: 2, label: "<projection> <message>" };
     if (isCallCommand(command))
@@ -129,6 +130,9 @@ function assignFlag(flags, name, value) {
         case "projection":
             flags.projection = String(value);
             return;
+        case "alias":
+            flags.alias = String(value);
+            return;
         case "timeout":
             flags.timeoutMs = parseWaitTimeout(String(value));
             return;
@@ -182,6 +186,9 @@ function assignFlag(flags, name, value) {
         case "complete":
             flags.complete = Boolean(value);
             return;
+        case "all":
+            flags.all = Boolean(value);
+            return;
         case "target":
             if (flags.target !== undefined) {
                 throw new FlowError("EMPTY_PARAM", "option --target may only be specified once");
@@ -244,21 +251,28 @@ function readValueFlag(name, token, eq, tokens, index) {
 function commissionConflictMessage(atForm, contractForm) {
     return `commission address supplied twice: ${atForm} and --contract ${contractForm}; use exactly one form`;
 }
-function noteContractFlag(flags, raw, previousRaw) {
-    if (previousRaw !== undefined || flags.contractId !== undefined) {
-        throw new FlowError("EMPTY_PARAM", `commission address supplied twice: --contract ${previousRaw ?? flags.contractId} and --contract ${raw}; use exactly one form`);
-    }
-    assignFlag(flags, "contract", raw);
-    return raw;
+function formatSelectorList(items) {
+    if (items.length <= 1)
+        return items[0] ?? "";
+    if (items.length === 2)
+        return `${items[0]} and ${items[1]}`;
+    return `${items.slice(0, -1).join(", ")}, and ${items[items.length - 1]}`;
+}
+function multiCommissionSelectorMessage(command, spellings) {
+    return `${command} accepts one commission address; got ${formatSelectorList(spellings)}`;
+}
+function commissionSelectorSpelling(source, value, rawToken) {
+    if (source === "at-address")
+        return rawToken ?? `@${value}`;
+    return `--contract ${rawToken ?? value}`;
 }
 export function parseCliArgs(tokens) {
     const { head, payload } = splitAtLiteralBoundary(tokens);
     const flags = {};
     const free = [];
     const seenFlagNames = new Set();
-    let atContractId;
-    let atToken;
-    let contractFlagRaw;
+    const atTokens = [];
+    const contractFlagRaws = [];
     let helpRequested = false;
     for (let index = 0; index < head.length; index += 1) {
         const token = head[index];
@@ -267,11 +281,7 @@ export function parseCliArgs(tokens) {
             continue;
         }
         if (token.startsWith("@")) {
-            if (atContractId !== undefined) {
-                throw new FlowError("EMPTY_PARAM", "command accepts at most one contract address");
-            }
-            atToken = token;
-            atContractId = normalizeContractAddress(token);
+            atTokens.push(token);
             continue;
         }
         if (/^-[A-Za-z]$/.test(token)) {
@@ -288,7 +298,7 @@ export function parseCliArgs(tokens) {
                 }
                 index += 1;
                 if (name === "contract") {
-                    contractFlagRaw = noteContractFlag(flags, value, contractFlagRaw);
+                    contractFlagRaws.push(value);
                 }
                 else {
                     assignFlag(flags, name, value);
@@ -307,6 +317,9 @@ export function parseCliArgs(tokens) {
         }
         const eq = token.indexOf("=");
         const name = parseFlagName(eq === -1 ? token : token.slice(0, eq));
+        if (name === "place") {
+            throw new FlowError("EMPTY_PARAM", "unknown option --place; use @addr or --contract <addr>");
+        }
         if (!CONTROL_FLAGS.has(name)) {
             throw new FlowError("EMPTY_PARAM", `unknown option: --${name}`);
         }
@@ -315,7 +328,7 @@ export function parseCliArgs(tokens) {
             const { value, nextIndex } = readValueFlag(name, token, eq, head, index);
             index = nextIndex;
             if (name === "contract") {
-                contractFlagRaw = noteContractFlag(flags, value, contractFlagRaw);
+                contractFlagRaws.push(value);
             }
             else {
                 assignFlag(flags, name, value);
@@ -329,14 +342,23 @@ export function parseCliArgs(tokens) {
             assignFlag(flags, name, true);
         }
     }
-    if (atContractId !== undefined && flags.contractId !== undefined) {
-        throw new FlowError("EMPTY_PARAM", commissionConflictMessage(atToken ?? `@${atContractId}`, contractFlagRaw ?? flags.contractId));
+    const { command, rest } = resolveCommand(free);
+    if (atTokens.length > 0 && contractFlagRaws.length > 0) {
+        throw new FlowError("EMPTY_PARAM", commissionConflictMessage(atTokens[0], contractFlagRaws[0]));
+    }
+    if (atTokens.length > 1) {
+        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, atTokens));
+    }
+    if (contractFlagRaws.length > 1) {
+        throw new FlowError("EMPTY_PARAM", multiCommissionSelectorMessage(command, contractFlagRaws.map((raw) => `--contract ${raw}`)));
     }
-    if (atContractId !== undefined) {
-        flags.contractId = atContractId;
+    if (atTokens.length === 1) {
+        flags.contractId = normalizeContractAddress(atTokens[0]);
         flags.contractAddressSource = "at-address";
     }
-    const { command, rest } = resolveCommand(free);
+    else if (contractFlagRaws.length === 1) {
+        assignFlag(flags, "contract", contractFlagRaws[0]);
+    }
     if (helpRequested) {
         return {
             command,
@@ -362,6 +384,17 @@ export function parseCliArgs(tokens) {
             ? `bind creates a commission and does not accept @${flags.contractId}; use -C/--cwd to select the repository`
             : `contract address @${flags.contractId} is not valid for ${command}`);
     }
+    if ((command === "wait" || command === "tell") && flags.contractId !== undefined) {
+        const selectorSpelling = commissionSelectorSpelling(flags.contractAddressSource === "at-address" ? "at-address" : "explicit-flag", flags.contractId, flags.contractAddressSource === "at-address" ? atTokens[0] : contractFlagRaws[0]);
+        const scopeOnlyMessage = `${command} requires a projection id or alias; ${selectorSpelling} only limits projection lookup, so add the projection address`;
+        if (command === "wait" && rest.length + payload.length === 0) {
+            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
+        }
+        if (command === "tell" && rest.length === 0) {
+            // Payload after -- is the message body, never the projection address.
+            throw new FlowError("EMPTY_PARAM", scopeOnlyMessage);
+        }
+    }
     const positional = [...rest, ...payload];
     if (isCallCommand(command)) {
         if (flags.akuma) {
@@ -374,6 +407,9 @@ export function parseCliArgs(tokens) {
             if (!name) {
                 throw new FlowError("EMPTY_PARAM", `${command} requires an agent name; use \`keiyaku ${command} NAME [prompt|-]\``);
             }
+            if (isResponseArtifactId(name)) {
+                throw new FlowError("EMPTY_PARAM", `artifact ${name} is a response artifact; call expects an Akuma profile name`);
+            }
             const parsedName = agentNameSchema.safeParse(name);
             if (!parsedName.success) {
                 throw new FlowError("EMPTY_PARAM", `${command} requires a valid agent name before the optional prompt`);