@aopslabs/aops 0.3.23 → 0.3.25

package/dist/commands/start.js

@@ -10,8 +10,7 @@ import { buildReadOnlyActivePlaybookNudgePackFromContext, } from '../utils/playb
 import { buildSessionGuidancePack } from '../utils/session-guidance.js';
 import { buildReadOnlyRepoFirstMemoryBriefFromContext } from './memory.js';
 import { applyCommonOptions, compactPayload } from '../utils/command.js';
-import { loadMissionResumePack } from './mission.js';
-import { START_DISCIPLINES, START_DISCIPLINE_PROFILES, START_DISCIPLINE_SIGNAL_MAPPING, startGuardrailGroupsForDiscipline, startGuardrailsForDiscipline, } from './start-disciplines.js';
+import { START_DISCIPLINES, START_DISCIPLINE_PROFILES, startGuardrailsForDiscipline, } from './start-disciplines.js';
 export const START_PROMPT_MIRROR_PATH = '.aops/hosted/prompts/aops-collaborative-startup.md';
 export const START_MODES = ['solo', 'solo+async-review', 'chat-room'];
 export const START_METHODS = START_DISCIPLINES;
@@ -131,11 +130,11 @@ const START_METHOD_RECIPES = {
     'coordinator-loop': {
         title: 'Coordinator loop',
         steps: [
-            'The coordinator researches independently, authors mission/ktask/plan records, and assigns work with canonical refs.',
+            'The coordinator researches independently, authors ktask/plan records, and assigns work with canonical refs.',
             'Implementers execute slices, open a review request per slice, and route questions to the coordinator instead of the operator.',
             'The coordinator reviews with code/runtime verification, then instructs the pathspec commit and the next assignment.',
         ],
-        defaultSurfaces: ['agentspace.mission', 'chatv3.room', 'projectman.implementation-plan', 'projectman.review-request'],
+        defaultSurfaces: ['chatv3.room', 'projectman.implementation-plan', 'projectman.review-request'],
     },
 };
 function serializeStartGuardrail(guardrail) {
@@ -159,8 +158,6 @@ function buildCheckpointCreateCommand(params) {
     ];
     if (params.position)
         parts.push('--position', quoteCommandArg(params.position));
-    if (params.missionId)
-        parts.push('--mission-id', params.missionId);
     if (params.sprintId)
         parts.push('--sprint-id', params.sprintId);
     if (params.phaseId)
@@ -214,386 +211,6 @@ function recommendStartDiscipline(answers) {
     reasons.push('single-agent or low-uncertainty execution');
     return { discipline: 'solo-pm-loop', reasons, signals };
 }
-function buildMissionPolicySeed(params) {
-    const profile = START_DISCIPLINE_PROFILES[params.selected];
-    const guardrails = startGuardrailsForDiscipline(params.selected);
-    const guardrailGroups = startGuardrailGroupsForDiscipline(params.selected);
-    return compactPayload({
-        discipline: {
-            id: params.selected,
-            version: profile.version,
-            enforcement: 'advisory',
-            selectedBy: params.explicit ? 'operator' : 'signals',
-            selectedVia: params.explicitSource ? `--${params.explicitSource}` : 'signal-mapping',
-            recommended: params.recommended,
-            signals: params.signals,
-            rationale: params.reasons,
-        },
-        guardrails: guardrails.map(serializeStartGuardrail),
-        guardrailGroups: {
-            execution: guardrailGroups.execution.map(serializeStartGuardrail),
-            closeout: guardrailGroups.closeout.map(serializeStartGuardrail),
-        },
-        closeout: {
-            required: true,
-            trigger: 'explicit',
-            guardrailIds: profile.closeoutGuardrailIds,
-            check: {
-                command: 'aops-cli mission check --closeout --id <mission-id> --json',
-                mode: 'read-only',
-                statusStates: ['present', 'missing', 'deferred-with-owner', 'not-applicable', 'waived-by-operator'],
-                note: 'Later closeout validator; reports evidence for closeout guardrails and does not mutate PM, memory, git, boards, or chat rooms.',
-            },
-            handoff: {
-                command: 'aops-cli mission handoff --id <mission-id> [--complete] --apply --json',
-                mode: 'later-apply-helper',
-                note: 'Conservative mission-level helper only; board and room closeout remain operator-approved lifecycle actions.',
-            },
-        },
-        review: profile.review,
-        issue: profile.issue,
-        memory: profile.memory,
-        plan: profile.plan,
-        vocabBridge: {
-            mode: {
-                value: params.mode,
-                meaning: 'transport/session shape',
-            },
-            discipline: {
-                value: params.selected,
-                meaning: 'policy preset plus guardrails, review, issue, memory, and plan rhythm',
-            },
-            method: {
-                value: params.selected,
-                aliasOf: 'discipline',
-                compatibility: 'kept for existing start consumers during the transition',
-            },
-        },
-        signalMapping: START_DISCIPLINE_SIGNAL_MAPPING,
-    });
-}
-function buildStartMissionPack(answers, params) {
-    const recommended = recommendStartDiscipline(answers);
-    const explicit = resolveExplicitDiscipline(answers);
-    const selected = explicit.discipline ?? recommended.discipline;
-    const resumeRef = normalize(answers.resume);
-    const missionRef = resumeRef ?? normalize(answers.mission);
-    const objective = normalize(answers.objective) ?? normalize(answers.task);
-    const planId = normalize(answers.plan);
-    const mode = normalize(answers.mode) ?? 'solo';
-    const board = normalize(answers.board);
-    const projectSlug = normalize(answers.projectSlug) ?? params.projectSlug;
-    const roomSlug = normalize(answers.roomSlug);
-    const checkpointStart = booleanFlag(answers.checkpointStart);
-    const checkpointAutoBetweenPhases = booleanFlag(answers.checkpointAutoBetweenPhases);
-    const checkpointMissionId = missionRef ?? '<mission-id>';
-    const checkpointStartCommand = buildCheckpointCreateCommand({
-        summary: objective ? `Mission start: ${objective}` : 'Mission start checkpoint',
-        position: planId ? `Starting implementation plan ${planId}` : 'Mission start',
-        missionId: checkpointMissionId,
-        sprintId: planId,
-    });
-    const checkpointPhaseTransitionCommand = buildCheckpointCreateCommand({
-        summary: '<phase transition checkpoint summary>',
-        position: '<from phase> -> <to phase>',
-        missionId: checkpointMissionId,
-        sprintId: planId ?? '<sprint-id>',
-        phaseId: '<phase-id>',
-    });
-    const checkpointSuggestedActions = [
-        checkpointStart
-            ? {
-                kind: 'mission-start-checkpoint',
-                policyPath: 'mission.policy.checkpoint.start',
-                mode: 'nudge-first',
-                applyRequired: true,
-                command: checkpointStartCommand,
-            }
-            : undefined,
-        checkpointAutoBetweenPhases
-            ? {
-                kind: 'phase-transition-checkpoint',
-                policyPath: 'mission.policy.checkpoint.autoBetweenPhases',
-                mode: 'nudge-first',
-                applyRequired: true,
-                command: checkpointPhaseTransitionCommand,
-            }
-            : undefined,
-    ].filter((action) => action !== undefined);
-    const syncStatusCommand = buildScopedSyncCommand({ action: 'status', projectSlug });
-    const syncDiffCommand = buildScopedSyncCommand({ action: 'diff', projectSlug });
-    const syncSuggestedActions = [
-        {
-            kind: 'cache-sync-status',
-            policyPath: 'mission.policy.sync.startStatus',
-            mode: 'read-only',
-            applyRequired: false,
-            command: syncStatusCommand,
-            note: 'Run at session start to inspect the read-only local cache vs the hosted server.',
-        },
-        {
-            kind: 'cache-sync-diff',
-            policyPath: 'mission.policy.sync.startDiff',
-            mode: 'read-only',
-            applyRequired: false,
-            command: syncDiffCommand,
-            note: 'Run at session start to inspect cache-vs-hosted drift; the hosted server is the source of truth.',
-        },
-    ];
-    const playbookSet = params.playbookSet;
-    const playbookNudges = params.playbookNudges;
-    const playbookSuggestedActions = playbookNudges?.suggestedActions ?? playbookSet?.suggestedActions ?? [];
-    const deferredBindings = [
-        planId
-            ? {
-                surface: 'projectman.implementation-plan',
-                status: 'deferred',
-                applyRequired: true,
-                command: `aops-cli plan update --id ${planId} --reference <ref> --apply --json`,
-            }
-            : {
-                surface: 'projectman.implementation-plan',
-                status: 'deferred',
-                applyRequired: true,
-                command: 'aops-cli plan create --task <task-id> --name "<name>" --goal "<goal>" --apply --json',
-            },
-        selected === 'build-review-chat' || mode === 'chat-room'
-            ? {
-                surface: 'projectman.review-request',
-                status: 'deferred',
-                applyRequired: true,
-                command: 'aops-cli pm review-request create --review-scope sprint:<plan-id> --target-agent <reviewer> --apply --json',
-            }
-            : undefined,
-        selected === 'design-first-consensus'
-            ? {
-                surface: 'agentspace.discuss',
-                status: 'deferred',
-                applyRequired: true,
-                command: 'aops-cli discuss start --title "<decision>" --question "<question>" --apply --json',
-            }
-            : undefined,
-        ...checkpointSuggestedActions.map((action) => ({
-            surface: 'agentspace.memory-item.checkpoint',
-            status: 'suggested',
-            applyRequired: true,
-            policyPath: action.policyPath,
-            command: action.command,
-        })),
-    ].filter((binding) => binding !== undefined);
-    const state = missionRef ? 'resume' : objective ? 'define' : 'implicit';
-    const mission = compactPayload({
-        ref: missionRef,
-        objective,
-        projectSlug,
-    });
-    const selectionReasons = explicit.discipline
-        ? [`explicit ${explicit.source === 'method' ? 'method alias' : 'discipline'} flag supplied`, ...recommended.reasons]
-        : recommended.reasons;
-    const policyBase = buildMissionPolicySeed({
-        selected,
-        recommended: recommended.discipline,
-        explicit: explicit.discipline !== undefined,
-        explicitSource: explicit.source,
-        reasons: selectionReasons,
-        signals: recommended.signals,
-        mode,
-    });
-    const policy = compactPayload({
-        ...policyBase,
-        orchestration: {
-            mode: 'read-only-pack',
-            sideEffects: 'none',
-            activeBindings: 'deferred',
-            note: 'start recommends PM/chat/discuss surfaces but does not create or bind records; run deferred commands with --apply to mutate truth surfaces.',
-        },
-        checkpoint: {
-            start: checkpointStart,
-            autoBetweenPhases: checkpointAutoBetweenPhases,
-            mode: 'nudge-first',
-            defaultWrite: false,
-            writeRequires: 'explicit aops-cli checkpoint create --apply --json',
-            suggestedActions: checkpointSuggestedActions,
-            note: 'start composes checkpoint policy and suggested actions only; it never writes checkpoint memory by itself.',
-        },
-        sync: {
-            mode: 'read-only-cache',
-            startStatus: true,
-            startDiff: true,
-            defaultWrite: false,
-            readOnly: true,
-            readOnlyAtStart: ['status', 'diff'],
-            sourceOfTruth: 'hosted-server',
-            note: 'Server-first: the hosted aops-server is the source of truth and .aops/** is a read-only local cache. start composes read-only status/diff actions only; there is no push-back from the cache.',
-            suggestedActions: syncSuggestedActions,
-        },
-        playbook: {
-            owner: 'agentspace.memory-item',
-            surface: 'agentspace.playbook',
-            mode: 'nudge-first-read-only',
-            defaultWrite: false,
-            scopes: ['project', 'session'],
-            durability: {
-                project: ['sticky', 'durable'],
-                session: ['short', 'durable', 'sticky'],
-            },
-            reviewState: ['accepted'],
-            count: playbookSet?.count ?? 0,
-            activeCount: playbookNudges?.count ?? playbookSet?.count ?? 0,
-            projectCount: playbookNudges?.project.count ?? playbookSet?.count ?? 0,
-            sessionCount: playbookNudges?.session.count ?? 0,
-            suggestedActions: playbookSuggestedActions,
-            closeoutCapture: playbookNudges?.closeoutCapture,
-            examples: playbookNudges?.examples,
-            note: 'start reads active accepted project/session playbooks as nudge-first guidance only; capture and promotion remain explicit playbook/experience commands with --apply.',
-        },
-        planning: {
-            owner: 'projectman',
-            surface: 'projectman.implementation-plan.*',
-            sprintBacked: true,
-            planId: planId ?? null,
-            note: 'implementation-plan id is the underlying sprint id',
-        },
-        chat: selected === 'build-review-chat' || mode === 'chat-room'
-            ? {
-                owner: 'chatv3',
-                roomSlug: roomSlug ?? null,
-                note: 'coordination and wake only; PM remains execution/review truth',
-            }
-            : undefined,
-        discuss: selected === 'design-first-consensus'
-            ? {
-                owner: 'agentspace.discuss',
-                note: 'record final stances before implementation when design uncertainty is material',
-            }
-            : undefined,
-    });
-    const policyJson = JSON.stringify(policy);
-    const guardrails = startGuardrailsForDiscipline(selected);
-    const guardrailGroups = startGuardrailGroupsForDiscipline(selected);
-    const profile = START_DISCIPLINE_PROFILES[selected];
-    return {
-        state,
-        ...(Object.keys(mission).length > 0 ? { mission } : {}),
-        ...(params.resumePack ? { resumePack: params.resumePack.result } : {}),
-        discipline: {
-            selected,
-            recommended: recommended.discipline,
-            explicit: explicit.discipline !== undefined,
-            selectedBy: explicit.discipline ? 'operator' : 'signals',
-            reasons: selectionReasons,
-            signals: recommended.signals,
-            profile,
-        },
-        method: {
-            selected,
-            recommended: recommended.discipline,
-            explicit: explicit.discipline !== undefined,
-            aliasOf: 'discipline',
-            reasons: selectionReasons,
-        },
-        guardrails,
-        guardrailGroups,
-        recipe: START_METHOD_RECIPES[selected],
-        policy,
-        policyJson,
-        ...(playbookSet ? { playbookSet } : {}),
-        ...(playbookNudges ? { playbookNudges } : {}),
-        startPack: compactPayload({
-            mode,
-            discipline: selected,
-            method: selected,
-            methodAliasOf: 'discipline',
-            board,
-            task: normalize(answers.task),
-            objective,
-            planId,
-            policySeed: {
-                target: 'mission.policy',
-                flag: '--policy-json',
-                json: policy,
-                jsonString: policyJson,
-                commandHint: missionRef
-                    ? 'aops-cli mission update --id <mission-id> --policy-json \'<result.mission.policyJson>\' --apply --json'
-                    : 'aops-cli mission create --objective "<objective>" --policy-json \'<result.mission.policyJson>\' --apply --json',
-            },
-            orchestration: {
-                mode: 'read-only-pack',
-                sideEffects: 'none',
-                activeBindings: 'deferred',
-                note: 'start recommends PM/chat/discuss surfaces but does not create or bind records; run deferred commands with --apply to mutate truth surfaces.',
-            },
-            checkpoint: {
-                policyPath: 'mission.policy.checkpoint',
-                start: checkpointStart,
-                autoBetweenPhases: checkpointAutoBetweenPhases,
-                mode: 'nudge-first',
-                defaultWrite: false,
-                suggestedActions: checkpointSuggestedActions,
-                note: 'checkpoint hooks are opt-in nudges; execute the suggested aops-cli checkpoint create command with --apply to write memory.',
-            },
-            sync: {
-                policyPath: 'mission.policy.sync',
-                mode: 'read-only-cache',
-                startStatus: true,
-                startDiff: true,
-                readOnly: true,
-                sourceOfTruth: 'hosted-server',
-                suggestedActions: syncSuggestedActions,
-                note: 'Server-first: run read-only status/diff at session start. .aops/** is a read-only local cache refreshed from the hosted server; there is no push-back.',
-            },
-            playbookSet,
-            playbookNudges,
-            planning: {
-                owner: 'projectman',
-                surface: 'projectman.implementation-plan.*',
-                sprintBacked: true,
-                planId: planId ?? null,
-                note: 'implementation-plan id is the underlying sprint id',
-            },
-            chat: selected === 'build-review-chat' || mode === 'chat-room'
-                ? {
-                    owner: 'chatv3',
-                    roomSlug: roomSlug ?? null,
-                    note: 'coordination and wake only; PM remains execution/review truth',
-                }
-                : undefined,
-            discuss: selected === 'design-first-consensus'
-                ? {
-                    owner: 'agentspace.discuss',
-                    note: 'record final stances before implementation when design uncertainty is material',
-                }
-                : undefined,
-            closeout: {
-                required: true,
-                trigger: 'explicit',
-                guardrailIds: profile.closeoutGuardrailIds,
-                checkCommandHint: 'aops-cli mission check --closeout --id <mission-id> --json',
-                handoffCommandHint: 'aops-cli mission handoff --id <mission-id> [--complete] --apply --json',
-                note: 'closeout is the before-leaving phase; deferred-with-owner is valid for unresolved PM truth, and board/room closeout stays operator-only',
-            },
-            deferredBindings,
-            nextCommands: [
-                missionRef
-                    ? 'aops-cli mission update --id <mission-id> --policy-json \'<result.mission.policyJson>\' --apply --json'
-                    : 'aops-cli mission create --objective "<objective>" --policy-json \'<result.mission.policyJson>\' --apply --json',
-                planId
-                    ? `aops-cli plan get --id ${planId} --json`
-                    : 'aops-cli plan create --task <task-id> --name "<name>" --goal "<goal>" --apply --json',
-                selected === 'build-review-chat'
-                    ? 'aops-cli pm review-request create --review-scope sprint:<plan-id> --target-agent <reviewer> --apply --json'
-                    : undefined,
-                selected === 'design-first-consensus'
-                    ? 'aops-cli discuss start --title "<decision>" --question "<question>" --apply --json'
-                    : undefined,
-                syncStatusCommand,
-                syncDiffCommand,
-                ...playbookSuggestedActions.map((action) => action.command),
-                ...checkpointSuggestedActions.map((action) => action.command),
-            ].filter(Boolean),
-        }),
-    };
-}
 function buildPromptRef(prompt, params) {
     return {
         bytes: Buffer.byteLength(prompt, 'utf8'),
@@ -610,12 +227,6 @@ function compactStartGuardrail(guardrail) {
         enforcementLevel: guardrail.enforcementLevel,
     });
 }
-function compactStartGuardrailGroups(groups) {
-    return compactPayload({
-        execution: groups.execution.map(compactStartGuardrail),
-        closeout: groups.closeout.map(compactStartGuardrail),
-    });
-}
 function compactStartProfile(profile) {
     return compactPayload({
         id: profile.id,
@@ -631,7 +242,6 @@ function compactPolicySeed(seed) {
         target: record.target,
         flag: record.flag,
         commandHint: record.commandHint,
-        jsonRef: 'result.mission.policyJson',
     });
 }
 function compactStartPack(startPack) {
@@ -699,49 +309,6 @@ function compactResumePack(resumePack) {
         playbookRef: 'result.sessionGuidance.layers.playbooks',
     });
 }
-function compactStartMissionPack(mission, params) {
-    return compactPayload({
-        state: mission.state,
-        mission: mission.mission,
-        resumePack: compactResumePack(mission.resumePack),
-        discipline: compactPayload({
-            selected: mission.discipline.selected,
-            recommended: mission.discipline.recommended,
-            explicit: mission.discipline.explicit,
-            selectedBy: mission.discipline.selectedBy,
-            reasons: mission.discipline.reasons,
-            signals: mission.discipline.signals,
-            profile: compactStartProfile(mission.discipline.profile),
-        }),
-        method: compactPayload({
-            selected: mission.method.selected,
-            recommended: mission.method.recommended,
-            explicit: mission.method.explicit,
-            aliasOf: mission.method.aliasOf,
-            reasons: mission.method.reasons,
-        }),
-        guardrailGroups: compactStartGuardrailGroups(mission.guardrailGroups),
-        recipe: mission.recipe,
-        policyJson: mission.policyJson,
-        policyRef: 'mission.policyJson',
-        startPack: compactStartPack(mission.startPack),
-        sessionGuidance: params.includeSessionGuidance ? mission.sessionGuidance : undefined,
-        sessionGuidanceRef: params.includeSessionGuidance ? undefined : 'result.sessionGuidance',
-    });
-}
-function appendMissionPackToPrompt(prompt, mission) {
-    const compactMission = compactStartMissionPack(mission, { includeSessionGuidance: true });
-    return `${prompt.trimEnd()}
-
-## Mission Orchestration Pack (read-only)
-
-Use this compact pack to choose the working discipline and PM/chat/discuss surfaces. \`discipline\` is the canonical policy preset; \`method\` is kept beside it as a compatibility alias. \`start\` is read-only in this v1 path: it does not create plans, bind chat rooms, open discuss topics, promote playbooks, or run sync by itself. Read \`sessionGuidance\` first for layered rules L1-L3: runtime rules, working-discipline guardrails, accepted playbooks, and ranked experience briefs. Read \`startPack.sync\`: run the read-only sync status/diff commands at session start to compare the local cache against the hosted server. Server-first: the hosted aops-server is the source of truth and \`.aops/**\` is a read-only local cache; there is no push-back from the cache. \`policyJson\` is the single mission-policy seed; \`startPack.policySeed.jsonRef\` points back to it instead of duplicating it. Treat \`deferredBindings\` as the apply-required follow-up list, and write Projectman records for durable task state.
-
-\`\`\`json
-${JSON.stringify(compactMission, null, 2)}
-\`\`\`
-`;
-}
 function isMultiAgentMode(mode) {
     return mode !== undefined && MULTI_AGENT_MODES.has(mode);
 }
@@ -906,7 +473,6 @@ function collectAnswers(options) {
         roomSlug: normalize(options.roomSlug),
         roomTitle: normalize(options.roomTitle),
         roles: normalize(options.roles),
-        mission: normalize(options.mission),
         resume: normalize(options.resume),
         objective: normalize(options.objective),
         discipline: normalize(options.discipline),
@@ -920,31 +486,6 @@ function collectAnswers(options) {
         checkpointAutoBetweenPhases: options.checkpointAutoBetweenPhases,
     };
 }
-async function loadStartMissionResumePack(options, answers, activeProject) {
-    const missionId = normalize(answers.resume);
-    if (!missionId)
-        return undefined;
-    const loaded = await loadMissionResumePack({
-        apiBaseUrl: options.apiBaseUrl,
-        accessToken: options.accessToken,
-        refreshToken: options.refreshToken,
-        timeoutMs: options.timeoutMs,
-        tenantId: options.tenantId,
-        locale: options.locale,
-        fallbackLocale: options.fallbackLocale,
-        scopeId: normalize(options.scopeId) ?? normalize(activeProject?.scopeId) ?? normalize(activeProject?.projectId),
-        scopeResolution: options.scopeResolution,
-        projectId: normalize(options.projectId) ?? normalize(activeProject?.projectId),
-        projectName: normalize(options.projectName),
-        id: missionId,
-        depth: normalize(options.missionResumeDepth) ?? 'light',
-        limit: options.missionResumeLimit ?? 8,
-        full: options.missionResumeFull,
-    });
-    if (!loaded)
-        throw new Error('Mission resume pack could not be loaded. Check host availability/auth and retry.');
-    return loaded;
-}
 function missingQuestions(answers, questions) {
     return questions.filter((question) => question.required && normalize(answers[question.key]) === undefined);
 }
@@ -998,17 +539,16 @@ export async function composeStart(options = {}) {
             depth: 'light',
         });
     const memoryBrief = memoryBriefResultFromEnvelope(memoryBriefEnvelope);
-    const activePlaybookMissionId = normalize(answers.resume) ?? normalize(answers.mission);
     const playbookNudges = await buildReadOnlyActivePlaybookNudgePackFromContext({
         repoRoot: rootDir,
         localRoot: activeProject?.localRoot,
         projectSlug,
-    }, {
-        missionId: activePlaybookMissionId,
-    });
+    }, {});
     const playbookSet = playbookNudges.project;
-    const missionResumePack = await loadStartMissionResumePack(options, answers, activeProject);
-    const missionBase = buildStartMissionPack(answers, { projectSlug, resumePack: missionResumePack, playbookSet, playbookNudges });
+    const recommendedDiscipline = recommendStartDiscipline(answers);
+    const explicitDiscipline = resolveExplicitDiscipline(answers);
+    const selectedDiscipline = explicitDiscipline.discipline ?? recommendedDiscipline.discipline;
+    const disciplineGuardrails = startGuardrailsForDiscipline(selectedDiscipline);
     const sessionGuidance = await buildSessionGuidancePack({
         repoRoot: rootDir,
         localRoot: activeProject?.localRoot,
@@ -1016,29 +556,20 @@ export async function composeStart(options = {}) {
     }, {
         surface: 'start',
         task: normalize(answers.task) ?? normalize(answers.objective),
-        missionId: normalize(answers.resume) ?? normalize(answers.mission),
         planId: normalize(answers.plan),
         area: normalize(options.area),
         limit: options.limit,
         playbookNudges,
         discipline: {
-            selected: missionBase.discipline.selected,
-            recommended: missionBase.discipline.recommended,
-            explicit: missionBase.discipline.explicit,
-            profile: missionBase.discipline.profile,
-            guardrails: missionBase.guardrails,
+            selected: selectedDiscipline,
+            recommended: recommendedDiscipline.discipline,
+            explicit: explicitDiscipline.discipline !== undefined,
+            profile: START_DISCIPLINE_PROFILES[selectedDiscipline],
+            guardrails: disciplineGuardrails,
         },
     });
-    const mission = {
-        ...missionBase,
-        sessionGuidance,
-        startPack: compactPayload({
-            ...missionBase.startPack,
-            sessionGuidance,
-        }),
-    };
     const composed = composeStartPrompt(body, answers, projectSlug, memoryBrief);
-    const prompt = appendMissionPackToPrompt(composed.prompt, mission);
+    const prompt = composed.prompt;
     const warnings = composed.warnings;
     let outFile;
     if (normalize(options.out)) {
@@ -1047,7 +578,7 @@ export async function composeStart(options = {}) {
         await fs.writeFile(outFile, prompt, 'utf-8');
     }
     const promptRef = buildPromptRef(prompt, { path: outFile, inline: true });
-    return { ...base, status: 'ready', missing: [], warnings, memoryBrief, mission, sessionGuidance, prompt, promptRef, outFile };
+    return { ...base, status: 'ready', missing: [], warnings, memoryBrief, sessionGuidance, prompt, promptRef, outFile };
 }
 export async function composeStartReminder(options = {}) {
     assertSupportedMode(normalize(options.mode));
@@ -1073,7 +604,6 @@ export async function composeStartReminder(options = {}) {
         localRoot: activeProject?.localRoot,
         projectSlug,
     }, {
-        missionId: normalize(answers.resume) ?? normalize(answers.mission),
         limit: parsePositiveInteger(options.limit),
     });
     const guardrails = startGuardrailsForDiscipline(selected);
@@ -1085,7 +615,6 @@ export async function composeStartReminder(options = {}) {
     }, {
         surface: 'start-reminder',
         task: normalize(answers.task) ?? normalize(answers.objective),
-        missionId: normalize(answers.resume) ?? normalize(answers.mission),
         planId: normalize(answers.plan),
         area: normalize(options.area),
         limit: options.limit,
@@ -1131,15 +660,8 @@ function serializableStartResult(result, params) {
             : undefined,
         outFile: result.outFile,
     };
-    if (params.compact) {
-        return {
-            ...base,
-            mission: result.mission ? compactStartMissionPack(result.mission, { includeSessionGuidance: false }) : undefined,
-        };
-    }
     return {
         ...base,
-        mission: result.mission,
         prompt: result.prompt,
     };
 }
@@ -1204,9 +726,7 @@ export function makeStartCommand() {
         .option('--room-slug <slug>', 'Hosted chat room slug (chat-room mode)')
         .option('--room-title <title>', 'Hosted chat room title (chat-room mode)')
         .option('--roles <list>', 'Operator-assigned roles, e.g. "claude=implementer, codex=reviewer, mzs=operator"')
-        .option('--mission <ref>', 'Mission id or title to resume/define in the startup pack')
-        .option('--resume <mission-id>', 'Hosted mission id to resume; embeds a compact mission resume pack')
-        .option('--objective <text>', 'Mission objective override; defaults to --task when omitted')
+        .option('--objective <text>', 'Objective override; defaults to --task when omitted')
         .option('--discipline <discipline>', `Working discipline: ${START_DISCIPLINES.join(' | ')}`)
         .option('--method <method>', `Compatibility alias for --discipline: ${START_METHODS.join(' | ')}`)
         .option('--work-size <size>', 'Work size signal for method recommendation: small | medium | large')
@@ -1214,16 +734,13 @@ export function makeStartCommand() {
         .option('--decision-uncertainty <level>', 'Decision uncertainty signal: low | medium | high')
         .option('--operator-interface <shape>', 'Operator interface signal: direct | delegated (delegated recommends coordinator-loop)')
         .option('--plan <id>', 'Existing implementation-plan id; this is the underlying sprint id')
-        .option('--checkpoint-start', 'Seed mission.policy.checkpoint.start=true and surface a checkpoint create suggested action; start remains read-only')
-        .option('--checkpoint-auto-between-phases', 'Seed mission.policy.checkpoint.autoBetweenPhases=true and surface phase-transition checkpoint nudges')
-        .option('--mission-resume-depth <depth>', 'Hosted mission resume depth: light | standard', 'light')
-        .option('--mission-resume-limit <n>', 'Maximum refs/rows for the compact hosted mission resume pack', '8')
-        .option('--mission-resume-full', 'Embed the full hosted mission resume skeleton instead of the compact summary')
+        .option('--checkpoint-start', 'Seed checkpoint.start=true and surface a checkpoint create suggested action; start remains read-only')
+        .option('--checkpoint-auto-between-phases', 'Seed checkpoint.autoBetweenPhases=true and surface phase-transition checkpoint nudges')
         .option('--reminder', 'Build a bounded read-only session guidance reminder pack instead of the full kickoff prompt')
         .option('--area <area>', 'Area hint for reminder/session guidance experience ranking')
         .option('--limit <n>', 'Maximum experience briefs in session guidance; default 3, max 5')
         .option('--compact', 'Use compact JSON output with promptRef instead of inline prompt (default for --json)')
-        .option('--full-output', 'With --json, include the full composed prompt and uncompact mission payload')
+        .option('--full-output', 'With --json, include the full composed prompt and uncompact passion payload')
         .option('--root <path>', 'Workspace root override (default: nearest repo config ancestor)')
         .option('--out <file>', 'Write the composed prompt to a file')
         .option('--no-memory-brief', 'Do not build/embed the read-only local memory cache brief')
@@ -1246,7 +763,6 @@ Examples:
   aops-cli start --mode solo --board ops --full-output --json
   aops-cli start --reminder --task "continue S1" --area aops-cli --json
   aops-cli start --mode chat-room --board ops --discipline build-review-chat --json
-  aops-cli start --resume <mission-id> --mode solo --board ops --json
   aops-cli start --mode chat-room --board ops \\
     --room-slug ops-room --room-title "Ops" \\
     --roles "claude=implementer, codex=reviewer, mzs=operator" --json
@@ -1263,7 +779,7 @@ Agent flow:
      after meaningful progress.
 `);
     applyCommonOptions(cmd, { withProject: true });
-    cmd.option('--scope-id <id>', 'Canonical owner scope override for hosted mission resume');
+    cmd.option('--scope-id <id>', 'Canonical owner scope override');
     cmd.option('--scope-resolution <mode>', 'Scope resolution for hosted reads: explicit | cascade');
     cmd.option('--tenant-id <id>', 'Tenant id header (x-tenant-id)');
     cmd.option('--locale <locale>', 'Locale header (x-locale)');