@agentbridge1/cli 0.0.1

package/dist/commands/start.js

@@ -0,0 +1,626 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStart = runStart;
+const config_1 = require("../config");
+const domain_resolution_1 = require("../domain-resolution");
+const errors_1 = require("../errors");
+const error_catalog_1 = require("../error-catalog");
+const http_1 = require("../http");
+const git_status_1 = require("../git-status");
+const session_1 = require("../session");
+const work_contract_1 = require("../work-contract");
+const server_sync_1 = require("../server-sync");
+const work_context_resolver_1 = require("../work-context-resolver");
+const PROMOTION_PLAN = {
+    draft: ["scoped", "assigned", "ready_for_session"],
+    scoped: ["assigned", "ready_for_session"],
+    assigned: ["ready_for_session"],
+    ready_for_session: [],
+    in_session: [],
+};
+function normalizeReason(value) {
+    const lower = value.toLowerCase();
+    if (lower.includes("not_project_member"))
+        return "not_project_member";
+    if (lower.includes("unauthorized"))
+        return "unauthorized";
+    if (lower.includes("forbidden"))
+        return "forbidden";
+    if (lower.includes("cr_no_owner"))
+        return "cr_no_owner";
+    if (lower.includes("owner work identity assigned") ||
+        lower.includes("owner work identity")) {
+        return "cr_no_owner";
+    }
+    if (lower.includes("caller_not_cr_owner"))
+        return "caller_not_cr_owner";
+    if (lower.includes("work_identity_not_in_project"))
+        return "work_identity_not_in_project";
+    if (lower.includes("cr_no_affected_domains"))
+        return "cr_no_affected_domains";
+    if (lower.includes("charter_not_confirmed") || lower.includes("charter")) {
+        return "charter_not_confirmed";
+    }
+    if (lower.includes("change_request_not_executable"))
+        return "change_request_not_executable";
+    if (lower.includes("already_in_session"))
+        return "already_in_session";
+    if (lower.includes("session_already_active"))
+        return "session_already_active";
+    return value;
+}
+function parseHttpErrorDetails(err) {
+    const raw = err.body?.trim();
+    if (!raw)
+        return { code: `http_${err.status}`, message: `HTTP ${err.status}` };
+    try {
+        const parsed = JSON.parse(raw);
+        const codeCandidate = typeof parsed?.error === "string"
+            ? parsed.error
+            : parsed?.error?.code ?? parsed?.error?.message ?? raw;
+        const messageCandidate = typeof parsed?.error === "string"
+            ? parsed.error
+            : parsed?.error?.message ?? parsed?.error?.code ?? raw;
+        return {
+            code: normalizeReason(codeCandidate),
+            message: messageCandidate,
+        };
+    }
+    catch {
+        return {
+            code: normalizeReason(raw),
+            message: raw,
+        };
+    }
+}
+function isCliHttpLike(err) {
+    if (!(err instanceof Error) && typeof err !== "object")
+        return false;
+    return (typeof err.status === "number" ||
+        typeof err.body === "string");
+}
+function parseUnknownHttpDetails(err) {
+    if (err instanceof http_1.CliHttpError) {
+        return parseHttpErrorDetails(err);
+    }
+    if (isCliHttpLike(err)) {
+        const rawBody = typeof err.body === "string" ? err.body : "";
+        if (rawBody.trim().length > 0) {
+            try {
+                const parsed = JSON.parse(rawBody);
+                const codeCandidate = typeof parsed?.error === "string"
+                    ? parsed.error
+                    : parsed?.error?.code ?? parsed?.error?.message ?? rawBody;
+                const messageCandidate = typeof parsed?.error === "string"
+                    ? parsed.error
+                    : parsed?.error?.message ?? parsed?.error?.code ?? rawBody;
+                return {
+                    code: normalizeReason(codeCandidate),
+                    message: messageCandidate,
+                };
+            }
+            catch {
+                return {
+                    code: normalizeReason(rawBody),
+                    message: rawBody,
+                };
+            }
+        }
+        const message = err.message ?? `HTTP ${err.status}`;
+        return {
+            code: normalizeReason(message),
+            message,
+        };
+    }
+    return { code: "unknown_error", message: "unexpected local/runtime error" };
+}
+function throwCatalogHttpFailure(err, fallbackCode, opts) {
+    if (err instanceof errors_1.SafeCliError)
+        throw err;
+    const details = parseUnknownHttpDetails(err);
+    const mapped = (0, error_catalog_1.mapServerCodeToCatalog)(details.code);
+    const code = (0, error_catalog_1.catalogEntryForCode)(mapped)?.code ??
+        (0, error_catalog_1.catalogEntryForCode)(fallbackCode)?.code ??
+        fallbackCode;
+    const parts = [];
+    if (opts?.what) {
+        parts.push(opts.what);
+    }
+    else {
+        const serverMsg = details.message?.trim();
+        if (serverMsg &&
+            serverMsg !== details.code &&
+            !serverMsg.startsWith("HTTP ") &&
+            serverMsg !== "unexpected local/runtime error") {
+            parts.push(serverMsg);
+        }
+    }
+    if (opts?.changeRequestId) {
+        parts.push(`Change request: ${opts.changeRequestId}.`);
+    }
+    if (opts?.appendSessionNotStarted) {
+        parts.push("Change request created but session not started.");
+    }
+    const what = parts.length > 0 ? parts.join(" ") : undefined;
+    throw (0, errors_1.catalogCliError)(code, what ? { what } : undefined);
+}
+function trimRequired(value, field) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        throw (0, errors_1.catalogCliError)(field === "--summary" ? "START_SUMMARY_REQUIRED" : "START_SCOPE_REQUIRED");
+    }
+    return trimmed;
+}
+async function ensureProjectAccess() {
+    const ctx = (0, config_1.contextFromConfig)();
+    try {
+        await (0, server_sync_1.fetchProjectPacket)(ctx);
+    }
+    catch (err) {
+        throwCatalogHttpFailure(err, "PROJECT_ACCESS_UNAUTHORIZED");
+    }
+}
+function ensureUnique(values) {
+    return [...new Set(values.filter((value) => value.trim().length > 0))];
+}
+function equalsIgnoreCase(left, right) {
+    if (!left || !right)
+        return false;
+    return left.toLowerCase() === right.toLowerCase();
+}
+function findIdentityByHint(identities, hint) {
+    const exactById = identities.find((identity) => identity.id === hint);
+    if (exactById)
+        return exactById;
+    const byName = identities.filter((identity) => equalsIgnoreCase(identity.name, hint));
+    if (byName.length === 1)
+        return byName[0];
+    return null;
+}
+function identityAgentLabel(identity) {
+    return identity.name?.trim() || identity.id;
+}
+function resolveStartIdentity(input) {
+    const { explicitAgentId, configuredActiveAgentId, callerIdentityId, projectId, identities } = input;
+    const callerIdentity = identities.find((identity) => identity.id === callerIdentityId) ?? null;
+    const ensureAuthorized = (identity, source) => {
+        if (identity.id !== callerIdentityId) {
+            throw (0, errors_1.catalogCliError)("START_IDENTITY_MISMATCH", {
+                what: `Agent "${identityAgentLabel(identity)}" resolves to WorkIdentity ${identity.id}, but this API key is bound to WorkIdentity ${callerIdentityId}.`,
+            });
+        }
+        return {
+            selectedAgentId: source === "explicit_agent"
+                ? explicitAgentId
+                : source === "config_active_agent"
+                    ? configuredActiveAgentId
+                    : identityAgentLabel(identity),
+            workIdentityId: identity.id,
+            workIdentityName: identity.name ?? identity.id,
+            source,
+        };
+    };
+    if (explicitAgentId) {
+        const explicitIdentity = findIdentityByHint(identities, explicitAgentId);
+        if (!explicitIdentity) {
+            throw (0, errors_1.catalogCliError)("START_AGENT_INVALID", {
+                what: `Agent "${explicitAgentId}" could not be resolved to a WorkIdentity in project ${projectId}.`,
+            });
+        }
+        return ensureAuthorized(explicitIdentity, "explicit_agent");
+    }
+    if (configuredActiveAgentId) {
+        const configuredIdentity = findIdentityByHint(identities, configuredActiveAgentId);
+        if (configuredIdentity) {
+            return ensureAuthorized(configuredIdentity, "config_active_agent");
+        }
+    }
+    if (callerIdentity) {
+        const selectedAgentId = identityAgentLabel(callerIdentity);
+        const warning = configuredActiveAgentId
+            ? `Configured activeAgentId ${configuredActiveAgentId} was not found in this project.\nUsing authenticated caller identity ${selectedAgentId}.\nSuggested fix: update .agentbridge/config.json activeAgentId.`
+            : undefined;
+        return {
+            selectedAgentId,
+            workIdentityId: callerIdentity.id,
+            workIdentityName: callerIdentity.name ?? callerIdentity.id,
+            source: "caller_identity_fallback",
+            warning,
+            suggestedActiveAgentId: selectedAgentId,
+        };
+    }
+    if (configuredActiveAgentId) {
+        throw (0, errors_1.catalogCliError)("IDENTITY_ACTIVE_AGENT_STALE", {
+            what: `Active agent "${configuredActiveAgentId}" could not be resolved to a WorkIdentity in project ${projectId}.`,
+        });
+    }
+    throw (0, errors_1.catalogCliError)("START_CALLER_IDENTITY_UNRESOLVED", {
+        what: `No resolvable WorkIdentity found for this API key in project ${projectId}.`,
+    });
+}
+async function resolveStartOwnership(input) {
+    const ctx = (0, config_1.contextFromConfig)();
+    const [callerPacket, identities, projectPacket] = await Promise.all([
+        (0, server_sync_1.fetchCallerIdentityPacket)(ctx),
+        (0, server_sync_1.listWorkIdentities)(ctx),
+        (0, server_sync_1.fetchProjectPacket)(ctx),
+    ]);
+    const callerPacketId = callerPacket?.work_identity?.id;
+    const fallbackIdentity = identities.length === 1
+        ? identities[0]
+        : input.explicitAgentId
+            ? findIdentityByHint(identities, input.explicitAgentId)
+            : input.configuredActiveAgentId
+                ? findIdentityByHint(identities, input.configuredActiveAgentId)
+                : null;
+    if (!callerPacketId && !fallbackIdentity) {
+        throw (0, errors_1.catalogCliError)("START_CALLER_IDENTITY_UNRESOLVED");
+    }
+    const callerIdentity = {
+        id: callerPacketId ?? fallbackIdentity?.id,
+        name: callerPacket?.work_identity?.name ?? fallbackIdentity?.name ?? null,
+        domainName: callerPacket?.work_identity?.domain?.name ?? fallbackIdentity?.domain?.name ?? null,
+    };
+    const resolvedIdentity = resolveStartIdentity({
+        explicitAgentId: input.explicitAgentId,
+        configuredActiveAgentId: input.configuredActiveAgentId,
+        callerIdentityId: callerIdentity.id,
+        projectId: ctx.projectId,
+        identities,
+    });
+    let resolvedDomain = input.explicitDomain?.trim() ||
+        (0, domain_resolution_1.inferLaneFromFiles)([input.scope], input.configuredDomains).laneDomain ||
+        callerIdentity.domainName ||
+        undefined;
+    let packetDomainOwner = null;
+    let packetDomainName = null;
+    try {
+        const domainPacket = await (0, server_sync_1.fetchDomainPacket)(ctx, {
+            domainName: resolvedDomain,
+            claimedPaths: [input.scope],
+            limit: 5,
+        });
+        const first = domainPacket.domains[0];
+        if (!resolvedDomain && first?.domain_name) {
+            resolvedDomain = first.domain_name;
+        }
+        packetDomainOwner = first?.owner_work_identity_id ?? null;
+        packetDomainName = first?.domain_name ?? null;
+    }
+    catch {
+        // Domain packet is best-effort for inference only.
+    }
+    if (!resolvedDomain) {
+        throw (0, errors_1.catalogCliError)("START_DOMAIN_UNRESOLVED");
+    }
+    const projectDomain = projectPacket.domains_summary.find((domain) => equalsIgnoreCase(domain.domain_name, resolvedDomain));
+    const ownerFromProjectPacket = projectDomain?.owner_work_identity_id ?? null;
+    const ownerFromPacket = packetDomainOwner;
+    const resolvedOwner = ownerFromProjectPacket ?? ownerFromPacket ?? callerIdentity.id;
+    if (resolvedOwner !== resolvedIdentity.workIdentityId) {
+        const ownerDomain = projectDomain?.domain_name ?? packetDomainName ?? resolvedDomain;
+        throw (0, errors_1.catalogCliError)("START_CR_OWNERSHIP_MISMATCH", {
+            what: `Resolved domain "${ownerDomain}" is owned by WorkIdentity ${resolvedOwner}, but this API key is bound to WorkIdentity ${resolvedIdentity.workIdentityId}.`,
+        });
+    }
+    return {
+        resolvedDomain,
+        ownerWorkIdentityId: resolvedIdentity.workIdentityId,
+        ownerWorkIdentityName: resolvedIdentity.workIdentityName,
+        resolvedAgentId: resolvedIdentity.selectedAgentId,
+        identitySource: resolvedIdentity.source,
+        identityWarning: resolvedIdentity.warning,
+        suggestedActiveAgentId: resolvedIdentity.suggestedActiveAgentId,
+    };
+}
+async function ensureChangeRequestReady(changeRequestId, ownerWorkIdentityId, resolvedDomain, scope) {
+    const ctx = (0, config_1.contextFromConfig)();
+    let cr = await (0, server_sync_1.getChangeRequest)(ctx, changeRequestId);
+    if (cr.ownerWorkIdentityId != null &&
+        cr.ownerWorkIdentityId.trim().length > 0 &&
+        cr.ownerWorkIdentityId !== ownerWorkIdentityId) {
+        throw (0, errors_1.catalogCliError)("START_CR_OWNERSHIP_MISMATCH", {
+            what: `Change request ${cr.id} is owned by ${cr.ownerWorkIdentityId}. Use an API key bound to that WorkIdentity or choose a different CR.`,
+        });
+    }
+    const nextAffectedDomains = ensureUnique([...(cr.affectedDomains ?? []), resolvedDomain]);
+    const nextScope = ensureUnique([...(cr.scope ?? []), scope]);
+    const needsPatch = cr.ownerWorkIdentityId !== ownerWorkIdentityId ||
+        nextAffectedDomains.length !== (cr.affectedDomains ?? []).length ||
+        nextScope.length !== (cr.scope ?? []).length;
+    if (needsPatch) {
+        cr = await (0, server_sync_1.updateChangeRequest)(ctx, cr.id, {
+            ownerWorkIdentityId,
+            affectedDomains: nextAffectedDomains,
+            scope: nextScope,
+        });
+    }
+    const plan = PROMOTION_PLAN[cr.status];
+    if (!plan) {
+        try {
+            cr = await (0, server_sync_1.updateChangeRequestStatus)(ctx, cr.id, "ready_for_session");
+            return { id: cr.id, status: cr.status };
+        }
+        catch {
+            throw (0, errors_1.catalogCliError)("START_CR_NOT_EXECUTABLE", {
+                what: `Change request ${cr.id} is in status "${cr.status}" and cannot start scoped work automatically.`,
+            });
+        }
+    }
+    for (const nextStatus of plan) {
+        cr = await (0, server_sync_1.updateChangeRequestStatus)(ctx, cr.id, nextStatus);
+    }
+    return { id: cr.id, status: cr.status };
+}
+function renderOtherSessions(lines, sessionIds) {
+    if (sessionIds.length === 0)
+        return lines;
+    return [
+        ...lines,
+        "",
+        "Other active sessions (not adopted):",
+        ...sessionIds.map((id) => `- ${id}`),
+    ];
+}
+async function executeStartWorkSession(opts) {
+    const summary = trimRequired(opts.summary ?? "", "--summary");
+    const scope = trimRequired(opts.scope ?? "", "--scope");
+    const cfg = (0, config_1.readConfig)();
+    const ctx = (0, config_1.contextFromConfig)();
+    await ensureProjectAccess();
+    const explicitAgentId = opts.agentId?.trim();
+    const configuredActiveAgentId = cfg.activeAgentId?.trim();
+    if (!explicitAgentId && !configuredActiveAgentId) {
+        throw (0, errors_1.catalogCliError)("START_MISSING_ACTIVE_AGENT");
+    }
+    const executionSurfaceId = cfg.executionSurfaceId?.trim();
+    if (!executionSurfaceId) {
+        throw (0, errors_1.catalogCliError)("START_EXECUTION_SURFACE_REQUIRED");
+    }
+    const ownership = await resolveStartOwnership({
+        explicitAgentId,
+        configuredActiveAgentId,
+        scope,
+        explicitDomain: opts.domain,
+        configuredDomains: cfg.domains ?? [],
+    });
+    const resolvedDomain = ownership.resolvedDomain;
+    const activeAgentId = ownership.resolvedAgentId;
+    const explicitResume = opts.resume === true;
+    const explicitCrId = opts.changeRequestId?.trim() || undefined;
+    const existingCrId = explicitCrId ?? (explicitResume ? cfg.activeChangeRequestId?.trim() || undefined : undefined);
+    const allowServerCurrentForCr = explicitResume || Boolean(explicitCrId);
+    let createdChangeRequestId;
+    let changeRequest;
+    try {
+        changeRequest =
+            existingCrId != null
+                ? await ensureChangeRequestReady(existingCrId, ownership.ownerWorkIdentityId, resolvedDomain, scope)
+                : await (async () => {
+                    const created = await (0, server_sync_1.createChangeRequest)(ctx, {
+                        title: summary,
+                        reason: summary,
+                        affectedDomains: [resolvedDomain],
+                        scope: [scope],
+                        ownerWorkIdentityId: ownership.ownerWorkIdentityId,
+                    });
+                    createdChangeRequestId = created.id;
+                    return ensureChangeRequestReady(created.id, ownership.ownerWorkIdentityId, resolvedDomain, scope);
+                })();
+    }
+    catch (err) {
+        if (err instanceof errors_1.SafeCliError)
+            throw err;
+        throwCatalogHttpFailure(err, "START_CR_NOT_EXECUTABLE", {
+            changeRequestId: createdChangeRequestId ?? existingCrId,
+            appendSessionNotStarted: Boolean(createdChangeRequestId),
+        });
+    }
+    const initialResolution = await (0, work_context_resolver_1.resolveWorkContext)(ctx, {
+        changeRequestId: changeRequest.id,
+        allowServerCurrentForCr,
+        includeOtherActiveSessions: true,
+    });
+    let workSessionId = initialResolution.binding?.workSessionId ?? null;
+    const otherSessionIds = initialResolution.otherActiveSessions.map((s) => s.id);
+    if (!workSessionId) {
+        try {
+            const sessionBaseline = (0, session_1.captureLocalSessionBaseline)();
+            const started = await (0, server_sync_1.openServerSession)(ctx, {
+                changeRequestId: changeRequest.id,
+                executionSurfaceId,
+                intent: summary,
+                claimedPaths: [scope],
+                activeAgentId,
+                inferredLaneDomain: resolvedDomain ?? null,
+                sessionBaseline: {
+                    gitHeadAtStart: sessionBaseline.gitHead,
+                    dirtyFilesAtStart: sessionBaseline.dirtyFilesAtStart,
+                    fingerprintsAtStart: sessionBaseline.fingerprintsAtStart,
+                    claimedPaths: [scope],
+                    startedAt: sessionBaseline.startedAt,
+                },
+            });
+            workSessionId = started.workSessionId;
+        }
+        catch (err) {
+            if (isCliHttpLike(err) || err instanceof http_1.CliHttpError) {
+                const details = parseUnknownHttpDetails(err);
+                if ((details.code === "already_in_session" ||
+                    details.code === "change_request_not_executable" ||
+                    details.code === "session_already_active") &&
+                    (explicitResume || Boolean(explicitCrId))) {
+                    const existing = await (0, work_context_resolver_1.findSingleActiveSessionForChangeRequest)(ctx, changeRequest.id);
+                    if (existing && "workSessionId" in existing) {
+                        workSessionId = existing.workSessionId;
+                    }
+                }
+                if (!workSessionId) {
+                    throwCatalogHttpFailure(err, "START_SESSION_OPEN_FAILED", {
+                        changeRequestId: changeRequest.id,
+                    });
+                }
+            }
+            else {
+                throwCatalogHttpFailure(err, "START_SESSION_OPEN_FAILED", {
+                    changeRequestId: changeRequest.id,
+                });
+            }
+        }
+    }
+    if (!workSessionId) {
+        throw (0, errors_1.catalogCliError)("START_SESSION_OPEN_FAILED", {
+            what: `Unable to resolve a work session for this change request. Change request: ${changeRequest.id}.`,
+        });
+    }
+    try {
+        (0, session_1.openLocalSession)({
+            agentId: activeAgentId,
+            laneDomain: resolvedDomain ?? null,
+            changeRequestId: changeRequest.id,
+            claimedPaths: [scope],
+            domains: cfg.domains ?? [],
+            serverSessionId: workSessionId,
+        });
+    }
+    catch (err) {
+        if (err instanceof errors_1.SafeCliError)
+            throw err;
+        throw (0, errors_1.catalogCliError)("START_LOCAL_SESSION_WRITE_FAILED");
+    }
+    (0, config_1.updateConfig)({ activeChangeRequestId: changeRequest.id });
+    const output = [
+        "AgentBridge work started",
+        `Project: ${ctx.projectId}`,
+        `Change request: ${changeRequest.id}`,
+        `Work session: ${workSessionId}`,
+        "Scope:",
+        `- ${scope}`,
+        ...(activeAgentId ? [`Agent: ${activeAgentId}`] : []),
+        `Work Identity: ${ownership.ownerWorkIdentityId}`,
+        `Identity source: ${ownership.identitySource}`,
+        ...(resolvedDomain ? [`Domain: ${resolvedDomain}`] : []),
+        ...(ownership.identityWarning ? [`Warning:\n${ownership.identityWarning}`] : []),
+        "Next: supervision is now active.",
+    ];
+    process.stdout.write(`${renderOtherSessions(output, [...new Set(otherSessionIds)]).join("\n")}\n`);
+    return {
+        changeRequestId: changeRequest.id,
+        workSessionId,
+        scope,
+        otherSessionIds: [...new Set(otherSessionIds)],
+    };
+}
+async function runSmartStart(opts = {}) {
+    const cfg = (0, config_1.readConfig)();
+    await ensureProjectAccess();
+    const explicitAgentId = opts.agentId?.trim();
+    const configuredActiveAgentId = cfg.activeAgentId?.trim();
+    if (!explicitAgentId && !configuredActiveAgentId) {
+        throw (0, errors_1.catalogCliError)("START_MISSING_ACTIVE_AGENT");
+    }
+    if (!cfg.executionSurfaceId?.trim()) {
+        throw (0, errors_1.catalogCliError)("START_EXECUTION_SURFACE_REQUIRED");
+    }
+    const ctx = (0, config_1.contextFromConfig)();
+    const resolution = await (0, work_context_resolver_1.resolveWorkContext)(ctx, {
+        allowServerCurrentForCr: true,
+        includeOtherActiveSessions: true,
+    });
+    if (resolution.state === "current_session_resolved") {
+        process.stdout.write("Active work session found - entering watch mode.\n");
+        if (!opts.skipWatch) {
+            const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
+            await runWatch({ allowDirty: true });
+        }
+        return;
+    }
+    if (resolution.state === "ambiguous_active_sessions") {
+        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
+        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
+    }
+    if (resolution.state === "mismatch" || resolution.state === "stale_orphan_session_detected") {
+        process.stdout.write(`${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}\n`);
+        throw (0, errors_1.catalogCliError)((0, error_catalog_1.workContextStateToCode)(resolution.state));
+    }
+    const inferred = (0, work_contract_1.inferWorkContract)({
+        prompt: opts.prompt,
+        branchName: (0, git_status_1.getBranchName)(),
+        dirtyFiles: (0, git_status_1.getDirtyWorkingTreeFiles)(),
+        activeChangeRequestId: cfg.activeChangeRequestId ?? null,
+    });
+    const draft = {
+        summary: inferred.summary,
+        scope: opts.scope?.trim() || inferred.scope,
+    };
+    const confirmed = await (0, work_contract_1.confirmWorkContract)(draft, {
+        nonInteractive: !process.stdin.isTTY,
+    });
+    if (!confirmed) {
+        process.stdout.write("Cancelled.\n");
+        return;
+    }
+    await executeStartWorkSession({
+        ...opts,
+        summary: confirmed.summary,
+        scope: confirmed.scope,
+    });
+    process.stdout.write("Work session started. Entering watch mode...\n");
+    if (!opts.skipWatch) {
+        const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
+        await runWatch({ allowDirty: true });
+    }
+}
+async function runStart(opts = {}) {
+    const explicitSummaryFlag = opts.summaryFlagProvided === true;
+    const explicitScopeFlag = opts.scopeFlagProvided === true;
+    const explicitInputProvided = opts.summary !== undefined || opts.scope !== undefined;
+    const explicitModeRequested = explicitSummaryFlag || explicitScopeFlag || explicitInputProvided;
+    const explicitSummary = opts.summary?.trim();
+    const explicitScope = opts.scope?.trim();
+    if (explicitModeRequested && explicitSummary && explicitScope) {
+        await executeStartWorkSession({ ...opts, summary: explicitSummary, scope: explicitScope });
+        if (!opts.skipWatch) {
+            const { runWatch } = await Promise.resolve().then(() => __importStar(require("./watch")));
+            await runWatch({ allowDirty: true });
+        }
+        return;
+    }
+    if (explicitModeRequested) {
+        throw (0, errors_1.catalogCliError)("START_EXPLICIT_PAIR_REQUIRED");
+    }
+    await runSmartStart(opts);
+}