@zq-silk/yui 0.14.0 → 0.14.2

package/dist/commands/agentCommands.js

@@ -119,6 +119,11 @@ function updateAgent(args, store) {
                 + "Stop that Role session before changing Agent launch settings.");
         }
         if (changes.adapter) {
+            const profile = findAgentProfileReference(tx, id);
+            if (profile !== null) {
+                throw usageError(`Agent ${id} adapter cannot change because Agent Profile ${profile.id} references it. `
+                    + "Update that explicit Profile or create a new Agent ID instead.");
+            }
             const binding = findRoleBindingReference(tx, id);
             if (binding !== null) {
                 throw usageError(`Agent ${id} adapter cannot change because ${describeReference(binding)} references it. `
@@ -156,6 +161,11 @@ function removeAgent(args, store) {
             throw usageError(`Agent ${id} cannot be removed because ${describeReference(binding)} references it. `
                 + "Migrate or remove that Role binding before removing this Agent.");
         }
+        const profile = findAgentProfileReference(tx, id);
+        if (profile !== null) {
+            throw usageError(`Agent ${id} cannot be removed because Agent Profile ${profile.id} references it. `
+                + "Update, inherit, or remove that Profile first.");
+        }
         const session = findNonStoppedSessionReference(tx, id);
         if (session !== null) {
             throw usageError(`Agent ${id} cannot be removed because ${describeReference(session)} `
@@ -227,6 +237,9 @@ function findRoleBindingReference(store, agentId) {
     }
     return null;
 }
+function findAgentProfileReference(store, agentId) {
+    return store.listAgentProfiles().find((profile) => profile.runtime.source === "explicit" && profile.runtime.agentId === agentId) ?? null;
+}
 function findNonStoppedSessionReference(store, agentId) {
     for (const set of store.listGlobalRoleSessionSets()) {
         const reference = sessionReference(set, agentId, { scope: "global", roleName: set.owner.roleName });

package/dist/commands/configCommands.js

@@ -5,7 +5,7 @@ import { DEFAULT_AGENT_LAUNCH_INACTIVITY_TIMEOUT_SECONDS, DEFAULT_CONTROLLER_TAS
 import { CONFIG_DEFINITIONS, CONFIG_KEYS, configDefinition, configDefinitionsForDomain } from "../config/configCatalog.js";
 import { resolveTimeZone } from "../output/timePresentation.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
-import { REVIEW_FINDING_LEDGER_MODES, REVIEW_TRIGGERS } from "../review/reviewConfig.js";
+import { REVIEW_TRIGGERS } from "../review/reviewConfig.js";
 /**
  * One uniform key model for every durable setting. Each catalog domain uses
  * the same show/set/clear contract; strategy settings such as `review` and
@@ -21,8 +21,7 @@ const RECONCILIATION_SET_USAGE = "Runtime config set usage: yui config runtime s
 const RESOURCES_GC_MODE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-mode <report|quarantine>.";
 const RESOURCES_GC_AUTO_QUARANTINE_SET_USAGE = "Resources config set usage: yui config resources set resources-gc-auto-quarantine <true|false>.";
 const LEADER_NEXT_ACTION_SET_USAGE = `Workflow config set usage: yui config workflow set leader-next-action <${LEADER_NEXT_ACTION_MODES.join("|")}>.`;
-const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final> "
-    + "[--finding-ledger <shadow|enforce>].";
+const REVIEW_SET_USAGE = "Workflow config set usage: yui config workflow set review --role <global-role> --trigger <always|leader|final>.";
 export function runConfigCommand(domain, args, store) {
     const keys = configDefinitionsForDomain(domain).map(({ key }) => key);
     const usage = `${capitalize(domain)} config usage: yui config ${domain} show | yui config ${domain} set <key> <value...> | yui config ${domain} clear <key>.`;
@@ -88,8 +87,7 @@ export function effectiveConfigData(config, domain) {
             ? null
             : {
                 roleName: config.review.roleName,
-                trigger: config.review.trigger,
-                findingLedger: config.review.findingLedger ?? "shadow"
+                trigger: config.review.trigger
             },
         completionInstallations: config.completionInstallations ?? {}
     };
@@ -545,8 +543,7 @@ const CONFIG_KEY_HANDLERS = [
         showLabel: "Review",
         showValue: (config) => (config.review === undefined
             ? "disabled"
-            : `${config.review.roleName} (${config.review.trigger}; finding ledger: ${config.review.findingLedger ?? "shadow"}`
-                + ")"),
+            : `${config.review.roleName} (${config.review.trigger})`),
         set(args, store) {
             if (args.length < 4 || args.length % 2 !== 0)
                 throw usageError(REVIEW_SET_USAGE);
@@ -554,7 +551,7 @@ const CONFIG_KEY_HANDLERS = [
             for (let index = 0; index < args.length; index += 2) {
                 const name = args[index];
                 const value = args[index + 1];
-                if (!["--role", "--trigger", "--finding-ledger"].includes(name)
+                if (!["--role", "--trigger"].includes(name)
                     || value === undefined
                     || options.has(name)) {
                     throw usageError(REVIEW_SET_USAGE);
@@ -572,23 +569,14 @@ const CONFIG_KEY_HANDLERS = [
                 throw usageError(`Global Role not found: ${roleName}.`);
             }
             const trigger = rawTrigger;
-            const rawLedgerMode = options.get("--finding-ledger")?.trim();
-            let findingLedger;
-            if (rawLedgerMode !== undefined) {
-                if (!REVIEW_FINDING_LEDGER_MODES.includes(rawLedgerMode)) {
-                    throw usageError(REVIEW_SET_USAGE);
-                }
-                findingLedger = rawLedgerMode;
-            }
             saveConfigKey(store, (config) => ({
                 ...config,
                 review: {
                     roleName,
-                    trigger,
-                    ...(findingLedger === undefined ? {} : { findingLedger })
+                    trigger
                 }
             }));
-            return `Review set to ${roleName} (${trigger}; finding ledger: ${findingLedger ?? "shadow"})\n`;
+            return `Review set to ${roleName} (${trigger})\n`;
         },
         clear(store) {
             saveConfigKey(store, (config) => {

package/dist/commands/configOverview.js

@@ -25,13 +25,14 @@ export function runConfigOverview(args, store, environment, identity, roleOption
         name,
         store.getGlobalRole(name)
     ]));
-    const profiles = store.listAgentProfiles();
+    const profileResult = runProfileCommand(["list"], store);
+    const profiles = profileResult.data.profiles;
     const completion = inspectCompletionStates(store.getConfig(), environment, identity);
     const roleOutput = runGlobalRoleCommand(["list"], store, roleOptions);
     if (typeof roleOutput !== "string") {
         throw new Error("Config overview received an invalid Role control result.");
     }
-    const profileOutput = runProfileCommand(["list"], store).output;
+    const profileOutput = profileResult.output;
     const agentOutput = runAgentCommand(["list"], store);
     const domainData = Object.fromEntries(CONFIG_DOMAINS.map((domain) => [
         domain,

package/dist/commands/durableJobCommands.js

@@ -99,7 +99,7 @@ async function acknowledgeJob(args, options) {
     if (options.store === undefined) {
         throw usageError("job acknowledge requires a Task store to resolve the caller.");
     }
-    taskLocalActor(options.store, options.environment, ref.taskId, options.home);
+    taskLocalActor(options.store, options.environment, ref.taskId);
     const caller = resolveJobCaller(options.environment, ref.taskId);
     await ensureFileTaskController(options.home, { environment: options.environment });
     const result = await acknowledgeDurableJob(options.home, ref.taskId, ref.jobId, caller);

package/dist/commands/executionAuditCommands.js

@@ -150,14 +150,9 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
     }
     if (report.reviews.status === "ok" && report.reviews.data !== undefined) {
         const reviews = report.reviews.data;
-        lines.push("", `Review rounds: ${reviews.total} total · ${reviews.completed} completed · ${reviews.failed} failed`, `Execution failures: ${reviews.infraFailed} · semantic negatives: ${reviews.semanticNegative}`, ...(reviews.deltaRechecks.total === 0
+        lines.push("", `Review rounds: ${reviews.total} total · ${reviews.completed} completed · ${reviews.failed} failed`, `Execution failures: ${reviews.infraFailed}`, ...(reviews.deltaRechecks === 0
             ? []
-            : [
-                `Delta-rechecks: ${reviews.deltaRechecks.total} total · `
-                    + `${reviews.deltaRechecks.equivalentAndAccepted} accepted · `
-                    + `${reviews.deltaRechecks.finding} finding · `
-                    + `${reviews.deltaRechecks.requiresFullReview} requiring Task Agent decision`
-            ]));
+            : [`Delta-rechecks: ${reviews.deltaRechecks} total`]));
     }
     else {
         lines.push("", ...sectionError("reviews", report));
@@ -224,7 +219,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 { header: "Type", minWidth: 8, maxWidth: 12 },
                 { header: "Turns", minWidth: 4, maxWidth: 6 },
                 { header: "WIs", minWidth: 3, maxWidth: 5 },
-                { header: "Review F/D/N", minWidth: 12, maxWidth: 16 },
+                { header: "Review F/D/X", minWidth: 12, maxWidth: 16 },
                 { header: "Integration A/F/R", minWidth: 17, maxWidth: 20 },
                 { header: "Pre-progress gen", minWidth: 12, maxWidth: 16 },
                 { header: "Terminal ws", minWidth: 10, maxWidth: 12 },
@@ -234,7 +229,7 @@ export function renderExecutionAudit(report, width = defaultTableWidth()) {
                 task.taskType ?? "unspecified",
                 String(task.turns.total),
                 String(task.workItems),
-                `${task.reviews.full}/${task.reviews.delta}/${task.reviews.nonSemantic}`,
+                `${task.reviews.full}/${task.reviews.delta}/${task.reviews.failed}`,
                 `${task.integrations.attempts}/${task.integrations.failed}/${task.integrations.repeatedIdentities}`,
                 String(task.providerGenerationsBeforeFirstProgress),
                 String(task.terminalWorkspaceCount),

package/dist/commands/globalRoleCommands.js

@@ -281,6 +281,12 @@ function unbindRole(args, store) {
     assertNoArguments(rest, "Role unbind usage: yui config role unbind <role> <agent-id>");
     store.transaction((tx) => {
         const role = requireRole(name, tx);
+        const profileId = profileUsingWorkerBinding(tx, role, agentId);
+        if (profileId !== null) {
+            throw usageError(`Agent ${agentId} cannot be unbound from Global Role worker because Agent Profile `
+                + `${profileId} derives non-model settings from that binding. `
+                + "Update, inherit, or remove that Profile first.");
+        }
         try {
             const result = unbindRoleAgent(role, tx.getGlobalRoleSessionSet(name), agentId, new Date());
             tx.saveGlobalRoleWithSessionSet(result.role, result.sessions);
@@ -291,6 +297,17 @@ function unbindRole(args, store) {
     });
     return `Unbound Agent ${agentId} from role ${name}\n`;
 }
+function profileUsingWorkerBinding(store, role, agentId) {
+    if (role.name !== "worker")
+        return null;
+    if (!Object.hasOwn(role.agentBindings, agentId))
+        return null;
+    if (agentId === role.activeAgentId)
+        return null;
+    const profile = store.listAgentProfiles().find((candidate) => (candidate.runtime.source === "explicit"
+        && candidate.runtime.agentId === agentId));
+    return profile?.id ?? null;
+}
 function enterRole(args, store) {
     const [rawName, ...rest] = args;
     const name = roleName(rawName);

package/dist/commands/profileCommands.js

@@ -1,14 +1,56 @@
 import { usageError } from "../errors/cliError.js";
 import { defaultTableWidth, renderTable } from "../output/table.js";
 import { BUILTIN_PROFILE_IDS, builtinAgentProfileInputs, createAgentProfile, updateAgentProfile } from "../profile/agentProfile.js";
+import { resolveAgentProfileRuntime, resolveAgentProfileView } from "../profile/agentProfileRuntime.js";
 import { parseRoleOptions } from "./roleConfiguration.js";
-export function runProfileCommand(args, store, now = () => new Date()) {
+/** Build the exact explicit Profile runtime that a command would persist. */
+export function previewProfileAgentConfigurationMutation(args, store) {
+    const [command, ...rest] = args;
+    let profile;
+    if (command === "add") {
+        const usage = "Profile add usage: yui config profile add <id> [--access <read|write>] [Profile settings].";
+        const [id, ...tail] = rest;
+        if (id === undefined || id.startsWith("--"))
+            throw usageError("Profile id is required.", usage);
+        const parsed = parseProfileOptions(tail, false, usage);
+        assertOptionPairs(parsed);
+        const runtime = addedRuntime(parsed, usage);
+        if (runtime.source === "global-worker")
+            return undefined;
+        profile = createAgentProfile({ id, runtime }, new Date(0));
+    }
+    else if (command === "update") {
+        const usage = "Profile update usage: yui config profile update <id> [--access <read|write>] [Profile settings].";
+        const [id, ...tail] = rest;
+        if (id === undefined || id.startsWith("--"))
+            throw usageError("Profile id is required.", usage);
+        const parsed = parseProfileOptions(tail, true, usage);
+        assertOptionPairs(parsed);
+        const current = requireProfile(store, id);
+        const runtime = updatedRuntime(current, parsed, usage);
+        if (runtime === undefined || runtime.source === "global-worker")
+            return undefined;
+        profile = updateAgentProfile(current, { runtime }, new Date(Math.max(Date.parse(current.updatedAt) + 1, 1)));
+    }
+    else {
+        return undefined;
+    }
+    const runtime = resolveAgentProfileRuntime(profile, store);
+    if (runtime.status === "unavailable")
+        throw usageError(runtime.reason);
+    return {
+        agentId: runtime.binding.agentId,
+        config: runtime.binding.config,
+        cwd: store.getConfig().defaultWorkspace ?? process.cwd()
+    };
+}
+export function runProfileCommand(args, store, now = () => new Date(), options = {}) {
     const [command, ...rest] = args;
     switch (command) {
-        case "add": return addProfile(rest, store, now());
+        case "add": return addProfile(rest, store, now(), options);
         case "list": return listProfiles(rest, store);
         case "show": return showProfile(rest, store);
-        case "update": return updateProfile(rest, store, now());
+        case "update": return updateProfile(rest, store, now(), options);
         case "remove": return removeProfile(rest, store);
         case "reset": return resetProfiles(rest, store, now());
         default:
@@ -17,45 +59,53 @@ export function runProfileCommand(args, store, now = () => new Date()) {
                 : `Unknown command: config profile ${command}`);
     }
 }
-function addProfile(args, store, now) {
+function addProfile(args, store, now, options) {
     const usage = "Profile add usage: yui config profile add <id> [--access <read|write>] [Profile settings].";
     const [id, ...tail] = args;
     if (id === undefined || id.startsWith("--"))
         throw usageError("Profile id is required.", usage);
     const parsed = parseProfileOptions(tail, false, usage);
+    assertOptionPairs(parsed);
     const profile = createAgentProfile({
         id,
         defaultAccess: parseAccess(parsed.one("--access") ?? "read"),
-        ...profileValues(parsed)
+        ...profileValues(parsed),
+        runtime: addedRuntime(parsed, usage)
     }, now);
+    validateExplicitRuntime(profile, store, options);
     store.transaction((tx) => {
         if (tx.getAgentProfile(profile.id) !== null) {
             throw usageError(`Agent Profile already exists: ${profile.id}.`);
         }
         tx.saveAgentProfile(profile);
     });
-    return { output: `Added Agent Profile ${profile.id}\n`, data: { profile } };
+    return {
+        output: `Added Agent Profile ${profile.id}\n`,
+        data: resolveAgentProfileView(profile, store)
+    };
 }
 function listProfiles(args, store) {
     noArgs(args, "Profile list usage: yui config profile list.");
-    const profiles = store.listAgentProfiles();
+    const profiles = store.listAgentProfiles().map((profile) => resolveAgentProfileView(profile, store));
     const output = profiles.length === 0
         ? "No Agent Profiles found.\n"
         : `${renderTable("Agent Profiles", [
             { header: "Profile", minWidth: 7, maxWidth: 24 },
             { header: "Revision", minWidth: 8, maxWidth: 10 },
             { header: "Access", minWidth: 6, maxWidth: 8 },
-            { header: "Description", minWidth: 12, maxWidth: 54 }
-        ], profiles.map((profile) => [
-            profile.id,
-            String(profile.revision),
-            profile.defaultAccess,
-            profile.description ?? "-"
-        ]), defaultTableWidth())}\n`;
+            { header: "Runtime", minWidth: 9, maxWidth: 14 },
+            { header: "Worker r", minWidth: 8, maxWidth: 10 },
+            { header: "Agent", minWidth: 7, maxWidth: 18 },
+            { header: "Model", minWidth: 7, maxWidth: 24 },
+            { header: "Effort", minWidth: 7, maxWidth: 12 },
+            { header: "Description", minWidth: 12, maxWidth: 48 }
+        ], profiles.map(profileListRow), defaultTableWidth())}\n`;
     return { output, data: { profiles } };
 }
 function showProfile(args, store) {
     const profile = requireProfile(store, oneArg(args, "Profile show usage: yui config profile show <id>."));
+    const view = resolveAgentProfileView(profile, store);
+    const runtime = view.runtime;
     return {
         output: `${[
             `Agent Profile: ${profile.id}`,
@@ -64,13 +114,23 @@ function showProfile(args, store) {
             `Description: ${profile.description ?? "-"}`,
             `Instructions: ${profile.instructions ?? "-"}`,
             `Skills: ${profile.skills?.join(", ") || "-"}`,
-            `Model: ${profile.model ?? "-"}`,
-            `Effort: ${profile.effort ?? "-"}`
+            `Runtime source: ${runtime.source}`,
+            `Worker revision: ${runtime.source === "global-worker"
+                ? runtime.workerRevision ?? "unavailable"
+                : "-"}`,
+            `Runtime status: ${runtime.status}`,
+            ...(runtime.status === "resolved"
+                ? [
+                    `Effective Agent: ${runtime.binding.agentId}/${runtime.binding.adapterId}`,
+                    `Effective Model: ${runtime.binding.config.model ?? "CLI default"}`,
+                    `Effective Effort: ${runtime.binding.config.effort ?? "CLI default"}`
+                ]
+                : [`Runtime unavailable: ${runtime.reason}`])
         ].join("\n")}\n`,
-        data: { profile }
+        data: view
     };
 }
-function updateProfile(args, store, now) {
+function updateProfile(args, store, now, options) {
     const usage = "Profile update usage: yui config profile update <id> [--access <read|write>] [Profile settings].";
     const [id, ...tail] = args;
     if (id === undefined || id.startsWith("--"))
@@ -80,14 +140,19 @@ function updateProfile(args, store, now) {
         throw usageError("At least one Profile option is required.", usage);
     assertOptionPairs(parsed);
     const current = requireProfile(store, id);
+    const runtime = updatedRuntime(current, parsed, usage);
     const updated = updateAgentProfile(current, {
         ...(parsed.has("--access") ? { defaultAccess: parseAccess(parsed.one("--access")) } : {}),
-        ...profilePatch(parsed)
+        ...profilePatch(parsed),
+        ...(runtime === undefined ? {} : { runtime })
     }, now);
+    if (runtime !== undefined) {
+        validateExplicitRuntime(updated, store, options);
+    }
     store.saveAgentProfile(updated);
     return {
         output: `Updated Agent Profile ${updated.id} to revision ${updated.revision}\n`,
-        data: { profile: updated }
+        data: resolveAgentProfileView(updated, store)
     };
 }
 function removeProfile(args, store) {
@@ -111,12 +176,11 @@ function resetProfiles(args, store, now) {
                     description: desired.description,
                     instructions: desired.instructions,
                     skills: desired.skills,
-                    model: desired.model,
-                    effort: desired.effort
+                    runtime: desired.runtime
                 }, now));
         }
     });
-    const profiles = BUILTIN_PROFILE_IDS.map((id) => requireProfile(store, id));
+    const profiles = BUILTIN_PROFILE_IDS.map((id) => resolveAgentProfileView(requireProfile(store, id), store));
     return {
         output: `Reset ${BUILTIN_PROFILE_IDS.length} built-in Agent Profiles\n`,
         data: { profiles }
@@ -127,8 +191,10 @@ const BASE_OPTIONS = [
     ["--description", "value"],
     ["--instructions", "value"],
     ["--skill", "repeatable"],
+    ["--agent", "value"],
     ["--model", "value"],
-    ["--effort", "value"]
+    ["--effort", "value"],
+    ["--inherit-worker", "flag"]
 ];
 const CLEAR_OPTIONS = [
     ["--clear-description", "flag"],
@@ -147,9 +213,7 @@ function profileValues(parsed) {
     return {
         ...(parsed.has("--description") ? { description: requiredText(parsed.one("--description")) } : {}),
         ...(parsed.has("--instructions") ? { instructions: requiredText(parsed.one("--instructions")) } : {}),
-        ...(parsed.has("--skill") ? { skills: parsed.many("--skill").map(requiredText) } : {}),
-        ...(parsed.has("--model") ? { model: requiredText(parsed.one("--model")) } : {}),
-        ...(parsed.has("--effort") ? { effort: requiredText(parsed.one("--effort")) } : {})
+        ...(parsed.has("--skill") ? { skills: parsed.many("--skill").map(requiredText) } : {})
     };
 }
 function profilePatch(parsed) {
@@ -157,11 +221,117 @@ function profilePatch(parsed) {
         ...profileValues(parsed),
         ...(parsed.has("--clear-description") ? { description: undefined } : {}),
         ...(parsed.has("--clear-instructions") ? { instructions: undefined } : {}),
-        ...(parsed.has("--clear-skills") ? { skills: undefined } : {}),
-        ...(parsed.has("--clear-model") ? { model: undefined } : {}),
-        ...(parsed.has("--clear-effort") ? { effort: undefined } : {})
+        ...(parsed.has("--clear-skills") ? { skills: undefined } : {})
     };
 }
+function addedRuntime(parsed, usage) {
+    assertRuntimeSourceOptions(parsed, usage);
+    const agentId = parsed.one("--agent")?.trim();
+    if (parsed.has("--inherit-worker") || agentId === undefined) {
+        if (parsed.has("--model") || parsed.has("--effort")) {
+            throw usageError("--model and --effort require --agent for an explicit Profile.", usage);
+        }
+        return { source: "global-worker" };
+    }
+    return {
+        source: "explicit",
+        agentId: requiredText(agentId),
+        ...(parsed.has("--model") ? { model: requiredText(parsed.one("--model")) } : {}),
+        ...(parsed.has("--effort") ? { effort: requiredText(parsed.one("--effort")) } : {})
+    };
+}
+function updatedRuntime(profile, parsed, usage) {
+    assertRuntimeSourceOptions(parsed, usage);
+    if (parsed.has("--inherit-worker"))
+        return { source: "global-worker" };
+    const runtimeOptions = [
+        "--agent", "--model", "--effort", "--clear-model", "--clear-effort"
+    ].some((option) => parsed.has(option));
+    if (!runtimeOptions)
+        return undefined;
+    const agentId = parsed.one("--agent")?.trim();
+    if (profile.runtime.source === "global-worker") {
+        if (agentId === undefined) {
+            throw usageError("An inherited Profile requires --agent before model or effort can be customized.", usage);
+        }
+        return {
+            source: "explicit",
+            agentId: requiredText(agentId),
+            ...(parsed.has("--model") ? { model: requiredText(parsed.one("--model")) } : {}),
+            ...(parsed.has("--effort") ? { effort: requiredText(parsed.one("--effort")) } : {})
+        };
+    }
+    const nextAgentId = agentId ?? profile.runtime.agentId;
+    const changesAgent = nextAgentId !== profile.runtime.agentId;
+    if (changesAgent) {
+        for (const [field, setOption, clearOption] of [
+            ["model", "--model", "--clear-model"],
+            ["effort", "--effort", "--clear-effort"]
+        ]) {
+            if (profile.runtime[field] !== undefined
+                && !parsed.has(setOption)
+                && !parsed.has(clearOption)) {
+                throw usageError(`Changing --agent requires ${setOption} or ${clearOption} so the old ${field} is not reused.`, usage);
+            }
+        }
+        return {
+            source: "explicit",
+            agentId: requiredText(nextAgentId),
+            ...(parsed.has("--model") ? { model: requiredText(parsed.one("--model")) } : {}),
+            ...(parsed.has("--effort") ? { effort: requiredText(parsed.one("--effort")) } : {})
+        };
+    }
+    return {
+        source: "explicit",
+        agentId: profile.runtime.agentId,
+        ...(parsed.has("--clear-model")
+            ? {}
+            : parsed.has("--model")
+                ? { model: requiredText(parsed.one("--model")) }
+                : profile.runtime.model === undefined ? {} : { model: profile.runtime.model }),
+        ...(parsed.has("--clear-effort")
+            ? {}
+            : parsed.has("--effort")
+                ? { effort: requiredText(parsed.one("--effort")) }
+                : profile.runtime.effort === undefined ? {} : { effort: profile.runtime.effort })
+    };
+}
+function assertRuntimeSourceOptions(parsed, usage) {
+    if (!parsed.has("--inherit-worker"))
+        return;
+    if (["--agent", "--model", "--effort", "--clear-model", "--clear-effort"]
+        .some((option) => parsed.has(option))) {
+        throw usageError("--inherit-worker cannot be combined with explicit Agent, model, or effort options.", usage);
+    }
+}
+function validateExplicitRuntime(profile, store, options) {
+    if (profile.runtime.source !== "explicit")
+        return;
+    const runtime = resolveAgentProfileRuntime(profile, store);
+    if (runtime.status === "unavailable")
+        throw usageError(runtime.reason);
+    options.validateAgentConfiguration?.({
+        agentId: runtime.binding.agentId,
+        config: runtime.binding.config,
+        cwd: store.getConfig().defaultWorkspace ?? process.cwd()
+    });
+}
+function profileListRow(view) {
+    const { profile, runtime } = view;
+    return [
+        profile.id,
+        String(profile.revision),
+        profile.defaultAccess,
+        runtime.source,
+        runtime.source === "global-worker"
+            ? runtime.workerRevision === undefined ? "-" : String(runtime.workerRevision)
+            : "-",
+        runtime.status === "resolved" ? runtime.binding.agentId : "unavailable",
+        runtime.status === "resolved" ? runtime.binding.config.model ?? "CLI default" : "-",
+        runtime.status === "resolved" ? runtime.binding.config.effort ?? "CLI default" : "-",
+        profile.description ?? "-"
+    ];
+}
 function assertOptionPairs(parsed) {
     for (const [value, clear] of [
         ["--description", "--clear-description"],

package/dist/commands/sessionCommands.js

@@ -104,7 +104,7 @@ function sameStopCandidate(session, candidate) {
     return session.agentId === candidate.agentId
         && session.adapterId === candidate.adapterId
         && session.nativeSessionId === candidate.nativeSessionId
-        && session.launchId === candidate.launchId
+        && session.runtimeGenerationId === candidate.runtimeGenerationId
         && session.sessionUpdatedAt === candidate.sessionUpdatedAt;
 }
 function renderSessionOwner(session) {