@astrosheep/keiyaku 2.8.0 → 2.8.2

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,10 +10,11 @@ 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."),
+    kill: command("kill", "Stop the current projection generation", ["keiyaku kill <projection-address>", "keiyaku @addr kill <projection-address>"], "none", ["cwd", "repo", "contract"], "Terminate the current generation while keeping the projection identity and tell ledger."),
     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.", {
         subcommands: ["list", "ls", "show"],
@@ -31,7 +32,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) {
@@ -84,6 +85,7 @@ export function renderCliHelp(version) {
         "  wait       Wait for an akuma projection.",
         "  revive     Revive an Akuma helper session.",
         "  tell       Send intent to an Akuma projection.",
+        "  kill       Stop the current Akuma generation.",
         "  log        Render a contract ledger.",
         "  akuma      Inspect helper profiles.",
         "  skills     Install bundled official skills.",

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";
@@ -34,6 +35,7 @@ import { buildBindDraftResponse, buildBindResponse, buildForfeitResponse, format
 import { buildCallResponse, renderAdoptedLaunchReceipt } from "./render/call.js";
 import { projectionDir, writeInboxTell } from "../core/projection-core.js";
 import { assertTellEffortSupported, tellProjection } from "../core/projection-wake.js";
+import { killProjectionGeneration } from "../core/projection-kill.js";
 import { resolveProjectionAddress } from "./projection-address.js";
 import { waitForProjection } from "../core/projection-wait.js";
 import { buildWaitResponse } from "./render/wait.js";
@@ -41,6 +43,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 +82,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 +100,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 +146,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 +164,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 +202,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 });
@@ -208,6 +234,27 @@ const CLI_COMMAND_SPECS = {
         };
         return address ? await withResolvedAddress(address, operation) : await operation();
     }),
+    kill: commandSpec("kill", async (_stdin, flags, _signal, positional) => {
+        const cwd = flags.contractId ? await repositoryDirectory(flags) : await projectDirectory(flags);
+        const [projectionAddress] = positional;
+        if (!projectionAddress)
+            throw new FlowError("EMPTY_PARAM", "kill requires a projection address");
+        const address = flags.contractId ? await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource) : undefined;
+        const operation = async () => {
+            const projection = await resolveProjectionAddress({
+                cwd,
+                address: projectionAddress,
+                scope: address,
+                verb: "kill",
+            });
+            const result = killProjectionGeneration(projectionDir(cwd, projection.id));
+            const line = result.status === "killed"
+                ? `× killed ${projection.id}`
+                : `· already resting ${projection.id}`;
+            return textResponse(line);
+        };
+        return address ? await withResolvedAddress(address, operation) : await operation();
+    }),
     log: commandSpec("log", async (_stdin, flags) => {
         const cwd = await repositoryDirectory(flags);
         const address = await resolveContractAddress(cwd, flags.contractId, flags.contractAddressSource);
@@ -232,6 +279,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 +338,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())),
 };