@astrosheep/keiyaku 1.0.2 → 2.8.1

package/build/cli/projection-address.js

@@ -1,11 +1,98 @@
-import { resolveProjectionPrefix } from "../core/projection-core.js";
-import { FlowError } from "../flow-error.js";
-export function resolveProjectionAddress(cwd, prefix, contractId) {
-    const resolved = resolveProjectionPrefix(cwd, prefix, contractId);
-    if (resolved.status === "resolved")
-        return resolved.id;
-    if (resolved.status === "none") {
-        throw new FlowError("EMPTY_PARAM", `projection not resolved${contractId ? ` within @${contractId}` : ""}: ${prefix}`);
-    }
-    throw new FlowError("EMPTY_PARAM", `projection address is ambiguous${contractId ? ` within @${contractId}` : ""}: ${prefix}; candidates:\n${resolved.candidates.join("\n")}`);
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { AddressResolutionError, buildObjectResolutionAttempt, } from "../core/addressing.js";
+import { resolveProjectionCoordinate } from "../core/projection-coordinate.js";
+import { isProjectionId, projectionDir } from "../core/projection-core.js";
+import { isProjectionAlias, readProjectionAlias } from "../core/projection-alias.js";
+import { readProjectionIdentity } from "../core/projection-identity.js";
+import { isResponseArtifactId } from "../core/response-artifact-id.js";
+import { isErrnoException } from "../errno.js";
+function isRealDirectory(directory) {
+    try {
+        return fs.lstatSync(directory).isDirectory();
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return false;
+        throw error;
+    }
+}
+export async function resolveProjectionAddress(input) {
+    const workdir = path.resolve(input.cwd);
+    // Scoped lookup reuses the commission carrier's repository root: zero Git probes.
+    // Unscoped lookup performs exactly one coordinate probe.
+    let repo;
+    let physicalRoot;
+    let attempt;
+    if (input.scope) {
+        repo = input.scope.repo;
+        physicalRoot = input.scope.repo.stableRoot;
+        attempt = buildObjectResolutionAttempt({
+            repo,
+            workdir,
+            expected: "projection",
+            supplied: input.address,
+            scope: {
+                commissionId: input.scope.binding.commissionId,
+                asTyped: input.scope.spelling.asTyped,
+            },
+            inference: ["commission-scoped projection lookup"],
+        });
+    }
+    else {
+        const coordinate = resolveProjectionCoordinate(input.cwd);
+        repo = coordinate.authority.kind === "repository"
+            ? { kind: "repository", stableRoot: coordinate.authority.stableRoot }
+            : { kind: "user" };
+        physicalRoot = coordinate.physicalRoot;
+        attempt = buildObjectResolutionAttempt({
+            repo,
+            workdir,
+            expected: "projection",
+            supplied: input.address,
+            inference: ["projection directory lookup"],
+        });
+    }
+    if (isResponseArtifactId(input.address)) {
+        throw new AddressResolutionError("EMPTY_PARAM", `artifact ${input.address} is a response artifact; ${input.verb} expects a projection id or alias`, { ...attempt, actual: "artifact" });
+    }
+    const suffix = input.scope
+        ? `within ${input.scope.spelling.asTyped}`
+        : repo.kind === "repository" ? `in repository ${repo.stableRoot}` : `in workdir ${workdir}`;
+    let id;
+    let alias;
+    if (input.address.includes("/")) {
+        if (!isProjectionId(input.address))
+            throw new AddressResolutionError("EMPTY_PARAM", `projection ${input.address} has no match ${suffix}`, attempt);
+        id = input.address;
+    }
+    else {
+        if (!isProjectionAlias(input.address))
+            throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
+        const target = readProjectionAlias(physicalRoot, input.address);
+        if (!target)
+            throw new AddressResolutionError("EMPTY_PARAM", `projection alias ${input.address} has no match ${suffix}`, attempt);
+        id = target;
+        alias = input.address;
+    }
+    const directory = projectionDir(physicalRoot, id);
+    if (!isRealDirectory(directory)) {
+        const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
+        throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
+    }
+    let identity;
+    try {
+        identity = readProjectionIdentity(directory);
+    }
+    catch (error) {
+        if (error instanceof Error && /ENOENT|no such file/i.test(error.message)) {
+            const subject = alias ? `projection alias ${alias} points to missing projection ${id}` : `projection ${id}`;
+            throw new AddressResolutionError("EMPTY_PARAM", `${subject} has no match ${suffix}`, attempt);
+        }
+        throw error;
+    }
+    if (input.scope && (identity.binding.kind !== "commission" || identity.binding.commissionId !== input.scope.binding.commissionId)) {
+        throw new AddressResolutionError("EMPTY_PARAM", `projection ${id} has no match ${suffix}`, attempt);
+    }
+    return { id, ...(alias ? { alias } : {}) };
 }

package/build/cli/render/address.js

@@ -25,7 +25,7 @@ export function renderResolvedAddressReceipt(address, facts = {}) {
                 `repo ${address.repo.stableRoot}`,
                 `workdir ${address.workdir}`,
                 facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-                facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+                facts.projectionId ? `projection ${facts.projectionId}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
             ].filter((part) => part !== undefined).join(" · ");
         }
         const repository = address.repo.kind === "repository"
@@ -37,7 +37,7 @@ export function renderResolvedAddressReceipt(address, facts = {}) {
             repository,
             `workdir ${address.workdir}`,
             facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-            facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+            facts.projectionId ? `projection ${facts.projectionId}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
         ].filter((part) => part !== undefined).join(" · ");
     }
     return [
@@ -46,7 +46,7 @@ export function renderResolvedAddressReceipt(address, facts = {}) {
         `repo ${address.repo.stableRoot}`,
         `target ${address.target.branch}`,
         facts.artifactId ? `artifact ${facts.artifactId}` : undefined,
-        facts.projectionId ? `projection ${facts.projectionId}` : undefined,
+        facts.projectionId ? `projection ${facts.projectionId}${facts.projectionAlias ? ` (${facts.projectionAlias})` : ""}` : undefined,
         `via ${sourceLabel(address)}`,
     ].filter((part) => part !== undefined).join(" · ");
 }
@@ -61,7 +61,16 @@ function renderAttemptCandidate(candidate) {
         candidate.matchedBy ? `matched by ${candidate.matchedBy}` : undefined,
     ].filter((part) => part !== undefined).join(" · ");
 }
+function isCommissionResolutionAttempt(attempt) {
+    return attempt.expected === "commission";
+}
 export function renderResolutionAttemptPreamble(attempt) {
+    if (!isCommissionResolutionAttempt(attempt)) {
+        return [
+            attempt.repo.kind === "repository" ? `At repo ${attempt.repo.stableRoot}` : "At no repository",
+            attempt.scope ? `scope ${attempt.scope.asTyped}` : undefined,
+        ].filter((part) => part !== undefined).join(" · ");
+    }
     const parts = [
         attempt.repo.kind === "repository" ? `At repo ${attempt.repo.stableRoot}` : "At no repository",
         attempt.spelling ? `address ${attempt.spelling.asTyped}` : undefined,

package/build/cli/render/call.js

@@ -2,10 +2,12 @@ import { assembleResponse, buildPayload, buildSection, formatMaybe, formatWarnin
 import { WARNING_SECTION_TITLE } from "./response-style.js";
 import { CONTENT_SECTION_TITLE, formatPersistenceSummary, formatCallCompletionHeading, formatCallNextAction, INFO_AKUMA_MAX_CHARS, projectionRejoinHintLines, } from "./shared.js";
 import { carryAddress, prependAddressReceipt, renderResolvedAddressReceipt } from "./address.js";
-export function renderAdoptedLaunchReceipt(address, projectionId) {
+export function renderAdoptedLaunchReceipt(address, projectionId, alias, previousAliasTarget) {
     return [
-        renderResolvedAddressReceipt(address, { projectionId }),
-        ...projectionRejoinHintLines(projectionId),
+        renderResolvedAddressReceipt(address, { projectionId, ...(alias ? { projectionAlias: alias } : {}) }),
+        ...(alias ? [`alias ${alias} → ${projectionId}`] : []),
+        ...(alias && previousAliasTarget ? [`(moved from ${previousAliasTarget}, still running)`] : []),
+        ...projectionRejoinHintLines(alias ?? projectionId),
     ].join("\n");
 }
 export function buildCallResponse(result, input) {
@@ -15,8 +17,11 @@ export function buildCallResponse(result, input) {
         const { session: _session, evidenceCwd: _evidenceCwd, address: _address, foregroundWait: _foregroundWait, ...responseData } = result;
         const output = {
             text: input.addressPlacement === "stdout"
-                ? renderAdoptedLaunchReceipt(result.address, result.projection.id)
-                : projectionRejoinHintLines(result.projection.id).join("\n"),
+                ? renderAdoptedLaunchReceipt(result.address, result.projection.id, result.projection.alias, result.projection.previousAliasTarget)
+                : [
+                    ...(result.projection.alias ? [`alias ${result.projection.alias} → ${result.projection.id}`] : []),
+                    ...projectionRejoinHintLines(result.projection.alias ?? result.projection.id),
+                ].join("\n"),
             payload: buildPayload(responseData),
         };
         switch (input.addressPlacement) {

package/build/cli/render/shared.js

@@ -135,14 +135,14 @@ export function projectionRejoinHintLines(projectionId) {
 }
 export function formatCallNextAction(input) {
     if (input.projection?.phase === "active") {
-        return projectionRejoinHintLines(input.projection.id).join("\n");
+        return projectionRejoinHintLines(input.projection.alias ?? input.projection.id).join("\n");
     }
     if (input.projection?.phase === "done") {
         return [
             "The akuma is back.",
             ...(input.artifactId ? [`record: ${input.artifactId}`] : []),
             "talk to it:",
-            `  » keiyaku tell ${input.projection.id} "your words"`,
+            `  » keiyaku tell ${input.projection.alias ?? input.projection.id} "your words"`,
         ].join("\n");
     }
     return "⟶ keiyaku status";

package/build/cli/render/status.js

@@ -15,6 +15,16 @@ function renderProjectionDiagnostics(row) {
         return "";
     return ` · diag ${row.diagnostics.map((diagnostic) => diagnostic.detail).join("; ")}`;
 }
+function renderProjectionOmission(board) {
+    if (!board.omitted)
+        return undefined;
+    const counts = ["failed", "dead", "done", "dismissed"]
+        .flatMap((state) => {
+        const count = board.omitted?.byState[state] ?? 0;
+        return count > 0 ? [`${count} ${state}`] : [];
+    });
+    return `  · +${board.omitted.total} not shown (${counts.join(" · ")}) — keiyaku status --all`;
+}
 function renderProjectionAge(row) {
     if (row.state === "done")
         return "done";
@@ -63,18 +73,19 @@ function renderProjectionRow(row) {
         : row.state === "startup-timeout"
             ? "minting"
             : row.state);
+    const identity = row.alias ? `${row.id} (${row.alias})` : row.id;
     let heading;
     if (row.state === "startup-timeout" || row.state === "unknown") {
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${row.id}    ${akuma} ${renderProjectionAge(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity}    ${akuma} ${renderProjectionAge(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else if (row.state === "minting") {
-        heading = `  ${glyph} ${row.id.padEnd(18)} (minting)${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity.padEnd(18)} (minting)${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     else {
         const age = renderProjectionAge(row).padEnd(9);
         const akuma = (row.akuma ?? "(unknown)").padEnd(18);
-        heading = `  ${glyph} ${row.id}    ${akuma} ${age}${renderProjectionTellCounts(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
+        heading = `  ${glyph} ${identity}    ${akuma} ${age}${renderProjectionTellCounts(row)}${renderProjectionDiagnostics(row)}`.trimEnd();
     }
     const activity = renderProjectionActivityLine(row);
     return activity ? [heading, activity] : [heading];
@@ -82,7 +93,11 @@ function renderProjectionRow(row) {
 export function renderProjectionStatusSection(board) {
     if (!board || board.rows.length === 0)
         return "";
-    return `${STATUS_PROJECTION_SECTION_TITLE}\n${board.rows.flatMap(renderProjectionRow).join("\n")}\n`;
+    const lines = board.rows.flatMap(renderProjectionRow);
+    const omission = renderProjectionOmission(board);
+    if (omission)
+        lines.push(omission);
+    return `${STATUS_PROJECTION_SECTION_TITLE}\n${lines.join("\n")}\n`;
 }
 function renderClaimReconciliationSection(recon) {
     if (!recon)

package/build/cli/render/wait.js

@@ -3,7 +3,7 @@ import { displayColumns, resolveLineColumns, truncateColumns } from "./line-widt
 import { projectionRejoinHintLines, textResponse } from "./shared.js";
 const WAIT_HEADER_MAX_COLUMNS = 60;
 function shortAddress(projectionId) {
-    return /-([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
+    return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
 }
 function phaseState(phase) {
     switch (phase) {
@@ -42,7 +42,7 @@ function waitStateText(snapshot) {
     }
 }
 function projectionIdentityParts(projectionId) {
-    const match = /^(.*)-([0-9a-f]{8})$/.exec(projectionId);
+    const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
     return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
 }
 function waitHeader(projectionId, akuma, snapshot, outputColumns) {
@@ -215,7 +215,7 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (rendered.lines.length === 0 && state === "running") {
         lines.push("   not a word out of it yet — pulse is steady");
     }
-    const nextActions = nextActionLines(projectionId, result, state);
+    const nextActions = nextActionLines(options.alias ?? projectionId, result, state);
     if (rendered.hasMutationFiles && nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);

package/build/config/provider-policy-ownership.js

@@ -0,0 +1,39 @@
+const EMPTY_OWNERSHIP = Object.freeze({
+    access: Object.freeze([]),
+    network: Object.freeze([]),
+    webSearch: Object.freeze([]),
+});
+function owns(config, key) {
+    return Object.prototype.hasOwnProperty.call(config, key);
+}
+export function nativePolicyOwnership(instanceName, instance) {
+    if (instance.kind !== "codex-sdk" && instance.kind !== "codex-app-server") {
+        return EMPTY_OWNERSHIP;
+    }
+    const config = instance.config;
+    if (!config)
+        return EMPTY_OWNERSHIP;
+    const access = [];
+    const network = [];
+    const webSearch = [];
+    const add = (target, key) => {
+        target.push({ path: `providers.${instanceName}.config.${key}`, value: config[key] });
+    };
+    if (owns(config, "sandbox_mode"))
+        add(access, "sandbox_mode");
+    if (owns(config, "approval_policy"))
+        add(access, "approval_policy");
+    for (const key of Object.keys(config)) {
+        if (key !== "sandbox_workspace_write" && !key.startsWith("sandbox_workspace_write."))
+            continue;
+        add(access, key);
+        add(network, key);
+    }
+    if (owns(config, "web_search"))
+        add(webSearch, "web_search");
+    return Object.freeze({
+        access: Object.freeze(access),
+        network: Object.freeze(network),
+        webSearch: Object.freeze(webSearch),
+    });
+}

package/build/config/settings.js

@@ -41,19 +41,9 @@ const CODEX_SDK_FORBIDDEN_THREAD_OPTIONS_KEYS = [
 const FORBIDDEN_CONFIG_KEYS = [
     "model",
     "model_reasoning_effort",
-    "sandbox_mode",
-    "sandbox_workspace_write",
-    "web_search",
-    "approval_policy",
 ];
 function isConfigKeyForbidden(key) {
-    // Exact match for model, model_reasoning_effort, sandbox_mode, web_search, approval_policy
-    if (FORBIDDEN_CONFIG_KEYS.includes(key))
-        return true;
-    // sandbox_workspace_write also rejects dotted subkeys from adapter-native TOML flattening
-    if (key.startsWith("sandbox_workspace_write."))
-        return true;
-    return false;
+    return FORBIDDEN_CONFIG_KEYS.includes(key);
 }
 const claudeSettingSourceSchema = z.enum(CLAUDE_SETTING_SOURCES);
 const writableRootItemSchema = z.string().superRefine((value, ctx) => {

package/build/core/addressing.js

@@ -1,6 +1,7 @@
 import * as path from "node:path";
 import { FlowError } from "../flow-error.js";
 import { listContractIds, readLedger } from "./ledger.js";
+import { isResponseArtifactId } from "./response-artifact-id.js";
 import { stableRepoRoot } from "./worktree-path.js";
 import { deriveContractState, isTerminalState, } from "./status.js";
 function normalizeAddressQuery(raw) {
@@ -66,10 +67,39 @@ export function buildResolutionAttempt(input) {
         workdir: path.resolve(input.workdir),
         expected: "commission",
         ...(input.spelling ? { spelling: input.spelling } : {}),
+        ...(input.actual !== undefined ? { actual: input.actual } : {}),
         candidates: [...(input.candidates ?? [])],
         inference: [...(input.inference ?? [])],
     };
 }
+export function buildObjectResolutionAttempt(input) {
+    return {
+        repo: input.repo,
+        workdir: path.resolve(input.workdir),
+        expected: input.expected,
+        supplied: input.supplied,
+        ...(input.actual !== undefined ? { actual: input.actual } : {}),
+        ...(input.scope ? { scope: input.scope } : {}),
+        candidates: [...(input.candidates ?? [])],
+        inference: [...(input.inference ?? [])],
+    };
+}
+export function buildArtifactResolutionAttempt(input) {
+    return {
+        ...buildObjectResolutionAttempt({
+            ...input,
+            expected: "artifact",
+        }),
+        expected: "artifact",
+    };
+}
+function commissionSelectorAsTyped(query, source) {
+    if (source === "at-address")
+        return `@${query}`;
+    if (source === "explicit-flag")
+        return `--contract ${query}`;
+    return query;
+}
 export class AddressResolutionError extends FlowError {
     attempt;
     constructor(code, message, attempt, options) {
@@ -162,63 +192,77 @@ export async function resolveUncommissionedRepositoryAddress(input) {
 export async function resolveContractAddress(cwd, raw, source = raw?.startsWith("@") ? "at-address" : "explicit-flag") {
     const workdir = path.resolve(cwd);
     const repo = await resolvedRepository(cwd);
-    const candidates = await commissionAddressCandidates(repo.stableRoot);
-    if (raw === undefined) {
-        const operable = candidates.filter((candidate) => candidate.active);
+    if (raw !== undefined) {
+        const query = normalizeAddressQuery(raw);
+        const spelling = { asTyped: commissionSelectorAsTyped(query, source), source };
+        // Lexical artifact fence: no ledger enumeration for rsp_<ULID>.
+        if (isResponseArtifactId(query)) {
+            throw new AddressResolutionError("EMPTY_PARAM", `artifact ${query} is a response artifact; expected a commission address`, {
+                repo,
+                workdir,
+                expected: "commission",
+                spelling,
+                candidates: [],
+                inference: [],
+                actual: "artifact",
+            });
+        }
+        const candidates = await commissionAddressCandidates(repo.stableRoot);
+        const matches = matchCommissionAddress(query, candidates);
         const attempt = {
             repo,
             workdir,
             expected: "commission",
-            candidates: attemptCandidates(operable),
-            inference: ["consulted active commission ledgers"],
+            spelling,
+            candidates: matches.map((candidate) => ({
+                commissionId: candidate.contractId,
+                matchedBy: candidate.spelling,
+                place: candidate.bind.data.place ?? null,
+                name: candidate.bind.data.name,
+                objective: candidate.bind.data.objective,
+                lifecycle: candidate.lifecycle,
+                target: { branch: candidate.bind.data.target },
+            })),
+            inference: [],
         };
-        if (operable.length === 1) {
-            const candidate = operable[0];
+        if (matches.length === 1) {
             return buildResolvedAddress({
                 repo,
                 workdir,
-                candidate,
-                matchedBy: "id",
-                asTyped: `@${candidate.contractId}`,
-                source: "sole-active",
-                inference: attempt.inference,
+                candidate: matches[0],
+                matchedBy: matches[0].spelling,
+                asTyped: attempt.spelling.asTyped,
+                source,
+                inference: [],
             });
         }
-        throw new AddressResolutionError(operable.length === 0 ? "EMPTY_PARAM" : "CONTRACT_AMBIGUOUS", operable.length === 0
-            ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
-            : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
+        if (matches.length === 0) {
+            throw new AddressResolutionError("EMPTY_PARAM", `unknown contract address @${query}`, attempt);
+        }
+        throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `contract address @${query} is ambiguous: ${attempt.candidates.map((candidate) => formatAmbiguousCandidate(query, candidate)).join("; ")}; use a full @commission-id`, attempt);
     }
-    const query = normalizeAddressQuery(raw);
-    const matches = matchCommissionAddress(query, candidates);
+    const candidates = await commissionAddressCandidates(repo.stableRoot);
+    const operable = candidates.filter((candidate) => candidate.active);
     const attempt = {
         repo,
         workdir,
         expected: "commission",
-        spelling: { asTyped: source === "at-address" ? `@${query}` : query, source },
-        candidates: matches.map((candidate) => ({
-            commissionId: candidate.contractId,
-            matchedBy: candidate.spelling,
-            place: candidate.bind.data.place ?? null,
-            name: candidate.bind.data.name,
-            objective: candidate.bind.data.objective,
-            lifecycle: candidate.lifecycle,
-            target: { branch: candidate.bind.data.target },
-        })),
-        inference: [],
+        candidates: attemptCandidates(operable),
+        inference: ["consulted active commission ledgers"],
     };
-    if (matches.length === 1) {
+    if (operable.length === 1) {
+        const candidate = operable[0];
         return buildResolvedAddress({
             repo,
             workdir,
-            candidate: matches[0],
-            matchedBy: matches[0].spelling,
-            asTyped: attempt.spelling.asTyped,
-            source,
-            inference: [],
+            candidate,
+            matchedBy: "id",
+            asTyped: `@${candidate.contractId}`,
+            source: "sole-active",
+            inference: attempt.inference,
         });
     }
-    if (matches.length === 0) {
-        throw new AddressResolutionError("EMPTY_PARAM", `unknown contract address @${query}`, attempt);
-    }
-    throw new AddressResolutionError("CONTRACT_AMBIGUOUS", `contract address @${query} is ambiguous: ${attempt.candidates.map((candidate) => formatAmbiguousCandidate(query, candidate)).join("; ")}; use a full @commission-id`, attempt);
+    throw new AddressResolutionError(operable.length === 0 ? "EMPTY_PARAM" : "CONTRACT_AMBIGUOUS", operable.length === 0
+        ? "no active commission found; pass @place, @slug, full @commission-id, or --contract <addr>"
+        : "multiple active commissions found; pass @place, @slug, full @commission-id, or --contract <addr>", attempt);
 }

package/build/core/call.js

@@ -11,6 +11,8 @@ import { buildCallTermsV2 } from "../agents/call-terms_v2.js";
 import { applySnapshotEffort, resolveAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
 import { restoreOutcome } from "../agents/harness/index.js";
 import { mintProjection, mintRepositoryProjection } from "./projection-mint.js";
+import { assertProjectionAlias, moveProjectionAlias } from "./projection-alias.js";
+import { projectionDir } from "./projection-core.js";
 import { waitForProjection } from "./projection-wait.js";
 import { requireResumableArtifact } from "./transcripts.js";
 import { appendDebugBlock } from "../telemetry/debug-log.js";
@@ -125,7 +127,7 @@ async function readCallKeiyakuContext(executionCwd, input) {
         if (input.bare && input.contractId) {
             const asTyped = input.contractAddressSource === "at-address"
                 ? `@${input.contractId}`
-                : input.contractId;
+                : `--contract ${input.contractId}`;
             throw new AddressResolutionError("EMPTY_PARAM", `commission address ${asTyped} cannot be combined with --bare`, buildResolutionAttempt({
                 repo: { kind: "user" },
                 workdir: executionCwd,
@@ -138,7 +140,7 @@ async function readCallKeiyakuContext(executionCwd, input) {
         if (input.contractId) {
             const asTyped = input.contractAddressSource === "at-address"
                 ? `@${input.contractId}`
-                : input.contractId;
+                : `--contract ${input.contractId}`;
             throw new AddressResolutionError("EMPTY_PARAM", `${asTyped} is a commission address, but ${ledgerCandidate} has no repository ledger; contract addressing requires a ledger`, buildResolutionAttempt({
                 repo: { kind: "user" },
                 workdir: executionCwd,
@@ -190,7 +192,7 @@ async function readCallKeiyakuContext(executionCwd, input) {
         });
         const asTyped = input.contractAddressSource === "at-address"
             ? `@${input.contractId}`
-            : input.contractId;
+            : `--contract ${input.contractId}`;
         throw new AddressResolutionError("EMPTY_PARAM", `commission address ${asTyped} cannot be combined with --bare`, buildResolutionAttempt({
             repo: repositoryAddress.repo,
             workdir: repositoryAddress.workdir,
@@ -240,6 +242,7 @@ async function readCallKeiyakuContext(executionCwd, input) {
         catch (error) {
             if (error instanceof AddressResolutionError
                 && error.code === "EMPTY_PARAM"
+                && error.attempt.expected === "commission"
                 && error.attempt.candidates.length === 0) {
                 return {
                     activeKeiyaku: false,
@@ -414,7 +417,7 @@ async function buildCallConfig(agentName, prompt, cwd, options) {
         idleTimeoutMs: options.idleTimeoutMs,
     });
     // Mint projection directory for supervisor pump.
-    const slug = launchSnapshot.akuma.name.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+    const slug = launchSnapshot.akuma.name;
     const publishProjection = async () => {
         const mintInput = {
             cwd: options.projectionCwd ?? cwd,
@@ -462,7 +465,29 @@ async function buildCallConfig(agentName, prompt, cwd, options) {
         finally {
             store.close();
         }
-        return { id: minted.id, dir: minted.dir, executionId };
+        const previousAliasTarget = options.alias === undefined
+            ? undefined
+            : moveProjectionAlias(options.projectionCwd ?? cwd, assertProjectionAlias(options.alias), minted.id);
+        const previousAliasTargetStillRunning = previousAliasTarget === undefined
+            ? undefined
+            : (() => {
+                try {
+                    const phase = observeProjectionLife(projectionDir(options.projectionCwd ?? cwd, previousAliasTarget), { nowMs: Date.now(), startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS }).phase;
+                    return phase === "minting" || phase === "active" || phase === "quiescent"
+                        ? previousAliasTarget
+                        : undefined;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+        return {
+            id: minted.id,
+            dir: minted.dir,
+            executionId,
+            ...(options.alias ? { alias: options.alias } : {}),
+            ...(previousAliasTargetStillRunning ? { previousAliasTarget: previousAliasTargetStillRunning } : {}),
+        };
     };
     // Every public launch has one durable projection object. Repository-free
     // authority changes the storage owner, not whether the object exists; mint
@@ -565,6 +590,7 @@ export async function runCall(input) {
             binding: keiyakuContext.address.binding,
             title,
             context: input.context,
+            ...(input.mode === "call" && input.alias !== undefined ? { alias: assertProjectionAlias(input.alias) } : {}),
         };
         if ((input.mode ?? "call") === "call") {
             const launched = await launchSubagentGeneration(launchSnapshot.akuma.name, prompt, executionCwd, executionOptions);
@@ -574,6 +600,8 @@ export async function runCall(input) {
                     nowMs: Date.now(),
                     startupTimeoutMs: PROJECTION_ADOPTION_TIMEOUT_MS,
                 }).phase,
+                ...(launched.projection.alias ? { alias: launched.projection.alias } : {}),
+                ...(launched.projection.previousAliasTarget ? { previousAliasTarget: launched.projection.previousAliasTarget } : {}),
             };
             input.onLaunch?.({ address: keiyakuContext.address, projection: adoptedProjection });
             if (input.detach) {