@getarbiter/cli 0.5.0

package/dist/commands/task-ship.js

@@ -0,0 +1,3 @@
+// SPDX-License-Identifier: Apache-2.0
+import{ensureDir,writeFileTranslated}from"../utils/fs.js";import{UserFacingError}from"../utils/errors.js";import{t}from"../i18n/index.js";import{join}from"node:path";import{z}from"zod";import{PHASE_ORDER,readUnifiedState,writeUnifiedState,appendLog,normalizeChainId,reviewStateOf}from"./task-state.js";import{runTaskAdvance}from"./task.js";import{sanitizeTaskId}from"../worktree/paths.js";import{autonomyAllows,CONSUMER_DEFAULT_PROFILE,SELF_ONLY_GATES,resolveShipProfile}from"./ship-profile.js";import{companionGreenInstruction,companionStatusLine}from"../integrations/companions.js";import{runCli}from"../utils/run-cli.js";import{planCrossModelSlots}from"../integrations/external-review.js";import{gatherTierSignals,normTier,widenTier}from"./ship-tier.js";import{appendChainIds,evaluateSeal,evaluateSeedSize,hasShipTaskId,resolveTrainLimits,shipTaskChanged}from"./ship-train.js";import{evaluateReviewRound,resolveReviewMaxRounds,reviewScopeLine}from"./ship-review.js";import{shipConfigFor}from"./ship-config.js";function normalizeShipTaskId(raw){const id=sanitizeTaskId(raw);if(!/^#\d+$/.test(id))throw new Error(`Invalid ship task id "${raw}" \u2014 expected a GitHub issue number like "1280" or "#1280".`);return id}const CompanionEvidenceV1=z.object({$schemaVersion:z.literal(1),companions:z.array(z.object({id:z.string().min(1),mode:z.enum(["lite","full"])})).min(1),diffStats:z.object({files:z.number().int().nonnegative(),insertions:z.number().int().nonnegative(),deletions:z.number().int().nonnegative()}),recordedAt:z.iso.datetime()}),REDTEAM_AGENTS={XS:1,S:2,Standard:3},REVIEW_AGENTS={XS:1,S:1,Standard:2};export const REVIEW_AGENTS_SECURITY_SURFACE=3;const FLOOR_XS=["bugs","type-safety","domain"],FLOOR_S_ADD=["test-quality"],FLOOR_STD_ADD=["security","data-integrity","silent-failures"];export function verticalsForTier(tier){return tier==="XS"?[...FLOOR_XS]:tier==="S"?[...FLOOR_XS,...FLOOR_S_ADD]:[...FLOOR_XS,...FLOOR_S_ADD,...FLOOR_STD_ADD]}function normalizeShipStepTail(tail){return Array.isArray(tail)?{chainIds:tail}:tail}export function shipStepFor(phase,tier,profile=CONSUMER_DEFAULT_PROFILE,taskId,tail=[]){const t2=normTier(tier),verticals=verticalsForTier(t2),normalizedTail=normalizeShipStepTail(tail);return(step=>({...step,verticals}))(shipStepBody(phase,t2,profile,{...normalizedTail,verticals,...taskId!==void 0?{taskId}:{}}))}function greenAction(profile){const base="Implement the minimum to make the tests pass.",companion=companionGreenInstruction(profile.companions);return companion?`${base} ${companion}`:base}function closeAction(){return"CLOSER mode: single named target, no new issues or refactor beyond the diff (findings \u2192 PARKING list, one line, no action). Same error twice \u2192 5-line root-cause, else declare BLOCKED. Commit the candidate, then run `node scripts/check-all.mjs L2` once before push. Foreground-wait on the PR/gate checks; never end the turn on a promise."}function closeIssuesPhrase(taskId,chainIds){if(chainIds.length===0)return"Close the issue, clean up the worktree.";const display=id=>id.startsWith("#")?id:`#${id}`;return`Close issues ${[taskId,...chainIds].filter(v=>!!v).map(display).join(", ")}, clean up the worktree.`}function completeAction(profile,taskId,chainIds=[]){const closePhrase=closeIssuesPhrase(taskId,chainIds);return profile.collaborationMode!=="trunk-solo"?`Commit, push, open a PR; await required review + checks, then merge. ${closePhrase}`:profile.mergeMode==="direct"?`Commit and push to the project's default branch through its gate (no PR). ${closePhrase}`:`Commit, push, open a PR, fast-forward merge once checks pass. ${closePhrase}`}function verificationSelfOnlyChecks(profile){return profile.isArbiterSelf?[...SELF_ONLY_GATES]:[]}const RED_TEAM_REVIEW_PHASE="red-team-review",RED_TEAM_REWORK_PHASE="red-team-rework",REFACTOR_PHASE="refactor";function isReviewPhase(phase){return phase===RED_TEAM_REVIEW_PHASE||phase===RED_TEAM_REWORK_PHASE||phase===REFACTOR_PHASE}function reviewScopeFor(plan){if(!(plan===void 0||plan.rounds<2||plan.base===null))return reviewScopeLine(plan.base,plan.rounds,plan.maxRounds)}function reviewPhaseStepBody(phase,t2,profile,context){const{verticals,externalModelAccess,review:reviewPlan}=context;if(phase===RED_TEAM_REVIEW_PHASE)return{phase,action:`Dispatch ${REDTEAM_AGENTS[t2]} red-team agent(s); route CRITICAL findings to red-team-rework.`,reviewAgents:REDTEAM_AGENTS[t2]};if(phase===RED_TEAM_REWORK_PHASE)return{phase,action:"Revise the plan for CRITICAL findings, then re-run red-team-review.",reviewAgents:0};const reviewAgents=profile.collaborationMode==="trunk-solo"?1:REVIEW_AGENTS[t2],externalCount=planCrossModelSlots({tier:t2,phase,totalSlots:reviewAgents,verticals,...profile.crossModelReview!==void 0?{cfg:profile.crossModelReview}:{},...externalModelAccess!==void 0?{access:externalModelAccess}:{}}).external.length,scope=reviewScopeFor(reviewPlan),step={phase,action:externalCount>0?`Clean up, then dispatch ${reviewAgents-externalCount} Anthropic code-review agent(s) + ${externalCount} Codex reviewer(s); panel total: ${reviewAgents}.`:`Clean up, then dispatch ${reviewAgents} code-review agent(s) + 1 adversarial verifier.`,reviewAgents,...scope!==void 0?{reviewScope:scope}:{}};return externalCount>0?{...step,externalReviewers:externalCount}:step}function shipStepBody(phase,t2,profile,context){if(isReviewPhase(phase))return reviewPhaseStepBody(phase,t2,profile,context);switch(phase){case"preflight":return{phase,action:"Open the worktree, read the issue, write task state.",command:"arbiter task init --id <id> --tier <tier> --plan <path>",reviewAgents:0};case"plan":return{phase,action:"Write the plan, then dispatch the plan-review agents; their PASS verdict in .arbiter/evidence/plan-review/<id>/latest.json is the gate.",command:`arbiter task advance --to ${nextPhase(phase)??"red-team-review"}`,reviewAgents:0};case"red":return{phase,action:"Write failing tests first (TDD red); record evidence.",command:"arbiter task record-red --test-path <path>",reviewAgents:0};case"green":return{phase,action:greenAction(profile),reviewAgents:0};case"verification":return{phase,action:`Run the ${profile.defaultGateLevel} gate; fix any failures.`,command:`node scripts/check-all.mjs ${profile.defaultGateLevel}`,reviewAgents:0,selfOnlyChecks:verificationSelfOnlyChecks(profile)};case"close":return{phase,action:closeAction(),reviewAgents:0};case"complete":return{phase,action:completeAction(profile,context.taskId,context.chainIds),reviewAgents:0}}}export function nextPhase(current){const idx=PHASE_ORDER.indexOf(current);return idx===-1||idx>=PHASE_ORDER.length-1?null:PHASE_ORDER[idx+1]??null}function advanceTargetFor(phase){return phase==="red-team-rework"?"red-team-review":nextPhase(phase)}function optionalShipStepLines(result){const lines=[];return result.step.command&&lines.push(`Command: ${result.step.command}`),result.step.reviewAgents>0&&lines.push(`Review agents: ${result.step.reviewAgents}`),result.step.externalReviewers!==void 0&&lines.push(`External reviewers: ${result.step.externalReviewers}`),result.step.reviewScope!==void 0&&lines.push(`Review scope: ${result.step.reviewScope}`),lines}export function buildShipStepLines(result,legacyTier){const tier=result.tier??normTier(legacyTier),lines=[`Phase: ${result.phase}${result.done?" (done)":""}`,`Action: ${result.step.action}`];lines.push(...optionalShipStepLines(result)),lines.push(`Tier: ${tier} \xB7 verticals: ${result.step.verticals.join(", ")}`),lines.push(`Governance: ${result.profile.governanceLevel}`),lines.push(`Autonomy: ${result.profile.autonomy}`),result.phase==="complete"&&!autonomyAllows(result.profile.autonomy,"auto-merge")&&lines.push("Autonomy gate: STOP \u2014 merging requires a human at L0 (set automation.autonomy or pass --autonomy).");const selfOnly=result.step.selfOnlyChecks??[];selfOnly.length>0&&lines.push(`Self-only checks: ${selfOnly.join(", ")}`);const companions=result.profile.companions;return companions.length>0&&lines.push(`Companion: ${companionStatusLine(companions)} \xB7 arbiter gates remain the safety net`),lines}function assertSeedWithinLimit(existing,taskId,chainIds,limits){const verdict=evaluateSeedSize(existing,taskId,chainIds,limits);if(verdict.ok)return;const seal={reason:"max-chain",detail:verdict.detail};throw new UserFacingError(t("errors.E_TRAIN_SEALED",seal))}function trainLimitsFor(ship,opts){return opts.trainLimits??resolveTrainLimits(ship)}function seedShipState(root,opts,limits){const taskId=opts.taskId!==void 0?normalizeShipTaskId(opts.taskId):void 0,chainIds=opts.chainIds!==void 0?opts.chainIds.map(normalizeChainId):void 0,existing=readUnifiedState(root);assertSeedWithinLimit(existing,taskId,chainIds,limits),(existing===null||taskId!==void 0||opts.tier!==void 0||opts.overrides!==void 0||chainIds!==void 0)&&writeUnifiedState(root,{...taskId!==void 0?{taskId}:{},...opts.tier!==void 0?{tier:opts.tier}:{},...opts.overrides!==void 0?{overrides:opts.overrides}:{},...chainIds!==void 0?{chainIds}:{}})}function shipProfileFor(root,opts){return opts.profileOverride??resolveShipProfile(root,{...opts.autonomy!==void 0?{autonomyOverride:opts.autonomy}:{},...opts.overrides!==void 0?{overrides:opts.overrides}:{}})}function advanceShipPhase(root,phase,opts){if(!opts.advance)return{phase,advanced:!1};const target=advanceTargetFor(phase);return target===null?{phase,advanced:!1}:(runTaskAdvance({to:target,dir:root,...opts.advanceOpts??{}}),appendLog(root,`ship \u2192 advanced to ${target}`),{phase:target,advanced:!0})}function companionEvidencePath(taskId,repoDir){return join(repoDir,".arbiter","evidence","companions",`${taskId}.json`)}function writeCompanionEvidence(root,taskId,profile,opts){if(profile.isArbiterSelf||profile.companions.length===0)return null;const evidence={$schemaVersion:1,companions:profile.companions.map(c=>({id:c.id,mode:c.mode})),diffStats:(opts.gatherCompanionDiffStats??gatherCompanionDiffStats)(root),recordedAt:opts.recordedAt??new Date().toISOString()},parsed=CompanionEvidenceV1.safeParse(evidence);if(!parsed.success)throw new Error(`Invalid companion evidence: ${parsed.error.message}`);const out=companionEvidencePath(taskId,root);return ensureDir(join(root,".arbiter","evidence","companions")),writeFileTranslated(out,`${JSON.stringify(parsed.data,null,2)}
+`),out}function gatherCompanionDiffStats(repoDir){const base=diffBase(repoDir),range=base?`${base}...HEAD`:"HEAD";try{return parseShortstat(runCli("git",["diff","--shortstat",range],{cwd:repoDir}).stdout)}catch{return{files:0,insertions:0,deletions:0}}}function diffBase(repoDir){for(const ref of["origin/main","main"])try{return runCli("git",["merge-base","HEAD",ref],{cwd:repoDir}).stdout.trim()}catch{}return null}function parseShortstat(shortstat){const files=Number((shortstat.match(/(\d+) files? changed/)??[])[1]??0),insertions=Number((shortstat.match(/(\d+) insertions?\(\+\)/)??[])[1]??0),deletions=Number((shortstat.match(/(\d+) deletions?\(-\)/)??[])[1]??0);return{files,insertions,deletions}}function writeVerificationCompanionEvidence(root,phase,taskId,profile,opts){phase!=="verification"||taskId===void 0||writeCompanionEvidence(root,taskId,profile,opts)}function shipTierFor(root,state,opts){const base=normTier(opts.tier??state?.tier);return base==="Standard"?base:widenTier(base,(opts.gatherTierSignals??gatherTierSignals)(root,state?.taskId??opts.taskId))}function trainSignalsFor(root,opts,state,now,chainSize=(state?.taskId?1:0)+(state?.chainIds??[]).length){const gather=opts.gatherTierSignals??gatherTierSignals;return{chainSize,openedAt:state?.timestamps.chainOpened,now,widenedTier:(opts.chainAddIds??[]).reduce((acc,raw)=>widenTier(acc,gather(root,normalizeChainId(raw))),"XS"),explicitSeal:opts.seal===!0}}function chainAddContext(opts,state){const additions=opts.chainAddIds??[],taskId=opts.taskId!==void 0?normalizeShipTaskId(opts.taskId):state?.taskId,taskChanged=shipTaskChanged(state,taskId),existing=opts.chainIds!==void 0?opts.chainIds.map(normalizeChainId):taskChanged?[]:state?.chainIds??[],primaryCount=hasShipTaskId(taskId)?1:0;return{signalState:taskChanged?null:state,currentSize:primaryCount+existing.length,projectedSize:primaryCount+appendChainIds(existing,additions).length}}function assertChainAddAllowed(root,opts,state,now,limits){const{signalState,currentSize,projectedSize}=chainAddContext(opts,state),currentVerdict=evaluateSeal(trainSignalsFor(root,opts,signalState,now,currentSize),limits);if(currentVerdict.sealed){const seal2={reason:currentVerdict.reason,detail:currentVerdict.detail};throw new UserFacingError(t("errors.E_TRAIN_SEALED",seal2))}if(projectedSize<=limits.maxChain)return;const seal={reason:"max-chain",detail:`the requested append would make the train carry ${projectedSize} issue(s), the limit is ${limits.maxChain}`};throw new UserFacingError(t("errors.E_TRAIN_SEALED",seal))}function prepareChainAdd(root,opts,limits){const additions=opts.chainAddIds??[];if(additions.length===0&&opts.seal!==!0)return null;const state=readUnifiedState(root),now=opts.now??new Date;return assertChainAddAllowed(root,opts,state,now,limits),{additions,now}}function persistTrainAppend(root,state,additions,now){const existing=state?.chainIds??[],chainIds=appendChainIds(existing,additions);writeUnifiedState(root,{chainIds,...state?.timestamps.chainOpened===void 0?{timestamps:{chainOpened:now.toISOString()}}:{}}),appendLog(root,`ship \u2192 train +${chainIds.length-existing.length} (${chainIds.join(", ")})`)}function applyPreparedChainAdd(root,prepared){prepared!==null&&persistTrainAppend(root,readUnifiedState(root),prepared.additions,prepared.now)}function headShaFor(root,opts){if(opts.headSha!==void 0)return opts.headSha;try{const sha=runCli("git",["rev-parse","HEAD"],{cwd:root}).stdout.trim();return sha.length>0?sha:null}catch{return null}}function resultingPhase(phase,opts){return opts.advance!==!0?phase:advanceTargetFor(phase)??phase}function prepareReviewRound(root,phase,opts,ship){if(resultingPhase(phase,opts)!==REFACTOR_PHASE||opts.advance!==!0&&opts.reviewRound!==!0)return null;const previous=reviewStateOf(readUnifiedState(root)),maxRounds=opts.reviewMaxRounds??resolveReviewMaxRounds(ship),forced=opts.forceReview===!0,verdict=evaluateReviewRound({rounds:previous.rounds,maxRounds,forced});if(!verdict.allowed)throw new UserFacingError(t("errors.E_REVIEW_ROUNDS_EXHAUSTED",{detail:verdict.detail}));return{rounds:previous.rounds+1,maxRounds,base:previous.lastReviewedSha,head:headShaFor(root,opts),forced}}function applyReviewRound(root,plan){if(plan===null)return;const wasForced=reviewStateOf(readUnifiedState(root)).forced===!0;writeUnifiedState(root,{review:{rounds:plan.rounds,lastReviewedSha:plan.head,...plan.forced||wasForced?{forced:!0}:{}}});const at=plan.head===null?"an unknown sha":plan.head.slice(0,7);appendLog(root,`review \u2192 round ${plan.rounds} at ${at}${plan.forced?" (forced)":""}`)}export function runTaskShip(opts={}){const root=opts.dir??process.cwd(),shipConfig=shipConfigFor(root),trainLimits=trainLimitsFor(shipConfig,opts),preparedChainAdd=prepareChainAdd(root,opts,trainLimits);seedShipState(root,opts,trainLimits),applyPreparedChainAdd(root,preparedChainAdd);const state=readUnifiedState(root);let phase=state?.phase??"preflight";const tier=shipTierFor(root,state,opts),preparedRound=prepareReviewRound(root,phase,opts,shipConfig),profile=shipProfileFor(root,opts),advancedPhase=advanceShipPhase(root,phase,opts);return phase=advancedPhase.phase,applyReviewRound(root,preparedRound),writeVerificationCompanionEvidence(root,phase,state?.taskId,profile,opts),{phase,step:shipStepFor(phase,tier,profile,state?.taskId,{chainIds:state?.chainIds??[],...opts.externalModelAccess!==void 0?{externalModelAccess:opts.externalModelAccess}:{},...preparedRound!==null?{review:preparedRound}:{}}),advanced:advancedPhase.advanced,done:phase==="complete",tier,profile}}

package/dist/commands/task-state.js

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync}from"node:fs";import{join}from"node:path";import{appendFileTranslated,ensureDir,rmTranslated,writeFile,readFileTranslated,assertWritten}from"../utils/fs.js";import{sanitizeTaskId}from"../utils/task-id.js";export const PHASE_ORDER=["preflight","plan","red-team-review","red","green","refactor","verification","close","complete"],LATERAL_PHASES=["red-team-rework"];export function isValidPhase(s){return PHASE_ORDER.includes(s)||LATERAL_PHASES.includes(s)}export function isTddPhase(s){return s==="RED"||s==="GREEN"||s==="REFACTOR"}export function reviewStateOf(state){return state?.review??{rounds:0,lastReviewedSha:null}}export function normalizeChainId(raw){const core=raw.trim().replace(/^#/,"");if(!/^\d+$/.test(core))throw new Error(`Invalid chain id "${raw}" \u2014 expected a GitHub issue number like "1280" or "#1280".`);return`#${core}`}const TASK_DIRNAME=".task",STATUS_FILENAME="status.json";export function taskStateDir(root){return join(root,".claude",TASK_DIRNAME)}export function statusPath(root){return join(taskStateDir(root),STATUS_FILENAME)}function logPath(root){return join(taskStateDir(root),"log.md")}function emptyCursor(){return{tddPhase:null,lastAction:"",nextAction:""}}function defaultState(){return{taskId:"",phase:"preflight",tier:"",plan:"",cursor:emptyCursor(),handoffStrategy:null,handoffReady:!1,runId:"",timestamps:{},gateDecisions:[]}}function canonicalTaskId(raw){const trimmed=raw.trim(),numeric=/^#?(\d+)$/.exec(trimmed);return numeric?`#${numeric[1]}`:trimmed}function msg(err){return err instanceof Error?err.message:String(err)}export function normalizePhase(raw,sourceLabel=STATUS_FILENAME){if(raw===void 0||raw==="")return"preflight";if(raw==="implementation")return"red";if(!isValidPhase(raw))throw new Error(`Corrupted phase value "${raw}" in ${sourceLabel}. Valid phases: ${PHASE_ORDER.join(", ")}. Remove .claude/.task/ and re-run with --to preflight to reset.`);return raw}function normalize(raw){if(raw.chainIds!==void 0&&(!Array.isArray(raw.chainIds)||raw.chainIds.some(id=>typeof id!="string")))throw new Error("Corrupted chainIds in status.json: expected an array of strings.");return{...defaultState(),...raw,phase:normalizePhase(raw.phase),cursor:{...emptyCursor(),...raw.cursor??{}},timestamps:raw.timestamps??{},gateDecisions:raw.gateDecisions??[]}}export function readUnifiedState(root){const p=statusPath(root);if(existsSync(p)){let parsed;try{parsed=JSON.parse(readFileTranslated(p,"utf-8"))}catch(err){throw new Error(`readUnifiedState: corrupted status at ${p}: ${msg(err)}. Remove .claude/.task/ and re-run with --to preflight to reset.`,{cause:err})}return normalize(parsed)}return seedFromLegacy(root)}export function readTaskId(root){const id=readUnifiedState(root)?.taskId.trim();return id&&id.length>0?id:void 0}export function writeUnifiedState(root,patch){const prev=readUnifiedState(root)??defaultState(),nextTaskId=patch.taskId===void 0?void 0:canonicalTaskId(patch.taskId),base=nextTaskId!==void 0&&nextTaskId.length>0&&prev.taskId.length>0&&canonicalTaskId(prev.taskId)!==nextTaskId?defaultState():prev,normalizedPatch={...patch,...nextTaskId!==void 0?{taskId:nextTaskId}:{}},merged={...base,...normalizedPatch,cursor:{...base.cursor,...normalizedPatch.cursor??{}},timestamps:{...base.timestamps,...normalizedPatch.timestamps??{}}};normalizedPatch.phase&&(merged.timestamps={...merged.timestamps,[normalizedPatch.phase]:new Date().toISOString()}),merged.runId||(merged.runId=`${process.pid}-${Date.now()}`);const result=writeFile(statusPath(root),JSON.stringify(merged,null,2)+`
+`,{skipPreserveCheck:!0});return assertWritten(result,`task-state document at ${statusPath(root)}`),merged}export function readOverride(root,path){return readUnifiedState(root)?.overrides?.[path]}export function writeOverride(root,path,value){const prev=readUnifiedState(root)?.overrides??{};writeUnifiedState(root,{overrides:{...prev,[path]:value}})}export function appendLog(root,line){ensureDir(taskStateDir(root)),appendFileTranslated(logPath(root),`- ${new Date().toISOString()} ${line}
+`)}const DOT_PHASE=".task-phase",DOT_ID=".task-id",DOT_TIER=".task-tier",DOT_PLAN=".task-plan",DOT_HANDOFF_READY=".task-handoff-ready",DOT_HISTORY=".task-phase-history",LEGACY_DOTFILES=[DOT_PHASE,DOT_ID,DOT_TIER,DOT_PLAN,DOT_HANDOFF_READY,DOT_HISTORY];function readDotfile(claudeDir,name){const p=join(claudeDir,name);if(!existsSync(p))return;const raw=readFileTranslated(p,"utf-8").trim();return raw.length>0?raw:void 0}function legacyPerIdStatusPath(claudeDir,idRaw){return join(claudeDir,".task-"+sanitizeTaskId(idRaw),STATUS_FILENAME)}export function seedFromLegacy(root){const claudeDir=join(root,".claude"),phaseRaw=readDotfile(claudeDir,DOT_PHASE),idRaw=readDotfile(claudeDir,DOT_ID);if(phaseRaw===void 0&&idRaw===void 0)return null;let rich={},richCorrupt=!1;if(idRaw){const richPath=legacyPerIdStatusPath(claudeDir,idRaw);if(existsSync(richPath))try{rich=JSON.parse(readFileTranslated(richPath,"utf-8"))}catch(err){richCorrupt=!0,process.stderr.write(`[arbiter] warn: legacy rich state at ${richPath} is unreadable (${msg(err)}); migrating flat dotfiles only and preserving the corrupt file for recovery.
+`)}}const seeded=normalize({...rich,taskId:idRaw??rich.taskId??"",phase:normalizePhase(phaseRaw,DOT_PHASE),tier:readDotfile(claudeDir,DOT_TIER)??rich.tier??"",plan:readDotfile(claudeDir,DOT_PLAN)??rich.plan??"",handoffReady:existsSync(join(claudeDir,DOT_HANDOFF_READY)),cursor:emptyCursor()}),result=writeFile(statusPath(root),JSON.stringify(seeded,null,2)+`
+`,{skipPreserveCheck:!0});assertWritten(result,`task-state document at ${statusPath(root)}`);for(const f of LEGACY_DOTFILES)rmTranslated(join(claudeDir,f),{force:!0});return idRaw&&!richCorrupt&&rmTranslated(join(claudeDir,".task-"+sanitizeTaskId(idRaw)),{recursive:!0,force:!0}),seeded}

package/dist/commands/task.js

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: Apache-2.0
+import{createHash}from"node:crypto";import{existsSync}from"node:fs";import{join}from"node:path";import{ensureDir,writeFileTranslated,readFileTranslated}from"../utils/fs.js";import{sanitizeTaskId}from"../utils/task-id.js";import{normalizeChainId}from"./task-state.js";import{getBoolFlag,getNumberFlag}from"../config/env-registry.js";import{PHASE_ORDER,LATERAL_PHASES,isValidPhase,readUnifiedState,writeUnifiedState,readTaskId,appendLog}from"./task-state.js";import{runCli}from"../utils/run-cli.js";import{evaluateMerged}from"./pr-merged.js";import{shipConfigFor,permitsGitHubCalls}from"./ship-config.js";import{evaluateSeedSize,resolveTrainLimits}from"./ship-train.js";import{UserFacingError}from"../utils/errors.js";import{t}from"../i18n/index.js";import{loadTddEvidence,extractFailureSignature}from"../evidence/tdd.js";import{pathExistsInCommit,resolveEvidenceCommit,tddEvidenceProducedOnBranch}from"../evidence/git-checks.js";import{detectHostCapabilities}from"../capabilities/host-probe.js";import{loadConfig}from"../utils/config.js";import{verifyGatePassMarker,verifyDoneEvidenceReceipt}from"../evidence/gate-binding.js";export class HandoffRequiredError extends Error{constructor(message){super(message),this.name="HandoffRequiredError"}}function currentPhase(root){return readUnifiedState(root)?.phase??"preflight"}const RECOVERY_TABLE={preflight:`Phase: preflight
+Action: Run /task #NNN to initialize the task branch and plan.
+Command: node scripts/check-all.mjs L1`,plan:`Phase: plan
+Action: Plan is being written. Review .claude/plans/ for existing plan draft.
+Next: Await user GO before editing files.`,"red-team-review":`Phase: red-team-review
+Action: Red-team agents running. Review .arbiter/evidence/redteam/<task-id>.json.
+Next: CRITICAL findings \u2192 arbiter task advance --to red-team-rework. All clear \u2192 arbiter task advance --to red.`,"red-team-rework":`Phase: red-team-rework
+Action: Critical findings require plan revision. Fix plan, then re-run red-team.
+Next: arbiter task advance --to red-team-review (re-triggers review) or --to plan (full replan).`,red:`Phase: red
+Action: Write failing tests first. No implementation yet.
+Next: Tests written \u2192 arbiter task advance --to green.`,green:`Phase: green
+Action: Make tests pass with minimal implementation.
+Next: All tests green \u2192 arbiter task advance --to refactor.`,refactor:`Phase: refactor
+Action: Clean up implementation. Tests must stay green.
+Next: Refactor done \u2192 arbiter task advance --to verification.`,verification:`Phase: verification
+Action: Gate running. Re-run: node scripts/check-all.mjs L2
+Next: Fix any failures, then arbiter task advance --to close.`,close:`Phase: close
+Action: CLOSER mode active \u2014 see .claude/rules/95-closer-mode.md. Single named target, no new issues/refactor beyond the diff (findings \u2192 PARKING), no gate-appeasement deletions. Same error twice \u2192 5-line root-cause or declare BLOCKED.
+Next: Commit, push, open/land the PR; foreground-wait on its checks. Merged + evidence \u2192 arbiter task advance --to complete.`,complete:`Phase: complete
+Action: Task is complete. Check if PR was created: gh pr list --head $(git branch --show-current)
+Next: Verify PR merged and issue closed.`};export function runTaskResume({dir}={}){const root=dir??process.cwd(),state=readUnifiedState(root),phase=state?.phase??"preflight",taskId=state?.taskId&&state.taskId.length>0?state.taskId:void 0,header=taskId?`Task: ${taskId}
+`:"",cursor=state?.cursor;if(cursor&&cursor.nextAction.trim().length>0){const lines=[`${header}Phase: ${phase}${cursor.tddPhase?` (${cursor.tddPhase})`:""}`,cursor.lastAction.trim().length>0?`Last action: ${cursor.lastAction}`:void 0,`Next action: ${cursor.nextAction}`].filter(l=>l!==void 0);process.stdout.write(lines.join(`
+`)+`
+`);return}process.stdout.write(`${header}${RECOVERY_TABLE[phase]}
+`)}export function runTaskInit(opts={}){const root=opts.dir??process.cwd(),patch={};opts.id!==void 0&&(patch.taskId=opts.id),opts.tier!==void 0&&(patch.tier=opts.tier),opts.plan!==void 0&&(patch.plan=opts.plan),opts.chainIds!==void 0&&(patch.chainIds=opts.chainIds.map(normalizeChainId)),assertSeedWithinTrainLimit(root,opts.id,patch.chainIds);const branch=detectCurrentBranch(root);branch!==void 0&&(patch.branch=branch);const state=writeUnifiedState(root,patch);appendLog(root,`init task ${state.taskId||"(unset)"} tier=${state.tier||"(unset)"}`)}function assertSeedWithinTrainLimit(root,taskId,chainIds){const verdict=evaluateSeedSize(readUnifiedState(root),taskId,chainIds,resolveTrainLimits(shipConfigFor(root)));if(verdict.ok)return;const seal={reason:"max-chain",detail:verdict.detail};throw new UserFacingError(t("errors.E_TRAIN_SEALED",seal))}function detectCurrentBranch(root){try{const name=runCli("git",["branch","--show-current"],{cwd:root,timeoutMs:5e3}).stdout.trim();return name.length>0?name:void 0}catch{return}}const GETTABLE_FIELDS=["phase","taskId","tier","plan","tddPhase","lastAction","nextAction"];function warnOnForeignTaskState(root,state){const recorded=state.branch;if(recorded===void 0||recorded.length===0)return;const actual=detectCurrentBranch(root);actual===void 0||actual===recorded||process.stderr.write(`WARNING: task state is foreign \u2014 .claude/.task/status.json records task ${state.taskId||"(none)"} on branch "${recorded}", but the checkout is on "${actual}". The value below belongs to that other task. Run \`arbiter task init --id <id>\` to seed this one.
+`)}export function runTaskGet(opts){const root=opts.dir??process.cwd(),s=readUnifiedState(root);s&&warnOnForeignTaskState(root,s);const value=(s?{phase:s.phase,taskId:s.taskId,tier:s.tier,plan:s.plan,tddPhase:s.cursor.tddPhase??"",lastAction:s.cursor.lastAction,nextAction:s.cursor.nextAction}:Object.fromEntries(GETTABLE_FIELDS.map(f=>[f,f==="phase"?"preflight":""])))[opts.field];value===void 0&&(process.stderr.write(`Unknown field "${opts.field}". Valid: ${GETTABLE_FIELDS.join(", ")}
+`),process.exit(2)),process.stdout.write(`${value}
+`)}const defaultRunner=(cmd,args)=>runCli(cmd,args,{timeoutMs:3e4});function planReviewDir(dir,sanitisedId){return join(dir,".arbiter","evidence","plan-review",sanitisedId)}function backlogPath(dir,sanitisedId){return join(dir,".arbiter","evidence",sanitisedId,"BACKLOG.md")}function readTaskIdFromDisk(dir){return readTaskId(dir)}export function runTaskRecover(opts={}){const dir=opts.dir??process.cwd(),rawId=opts.taskId!==void 0&&opts.taskId.length>0?opts.taskId:readTaskIdFromDisk(dir);if(rawId===void 0){process.stdout.write(`No task id provided and no active task found. Pass --task <id> to recover.
+`);return}const sanit=sanitizeTaskId(rawId),runner=opts.runner??defaultRunner,parts=[];parts.push(`\u2501\u2501\u2501 Recovery for task ${rawId} (sanitized: ${sanit}) \u2501\u2501\u2501
+`);const backlog=backlogPath(dir,sanit);existsSync(backlog)?(parts.push("\u2501\u2501\u2501 Layer 1: BACKLOG.md \u2501\u2501\u2501"),parts.push(readFileTranslated(backlog,"utf-8")),parts.push(`\u2501\u2501\u2501 END Layer 1 \u2501\u2501\u2501
+`)):parts.push(`Layer 1: no BACKLOG.md at ${backlog}
+`),parts.push(`\u2501\u2501\u2501 Layer 2: CHECKPOINT(#${sanit}) commits \u2501\u2501\u2501`);try{const r=runner("git",["log","-F","--grep",`CHECKPOINT(#${sanit})`,"--max-count=10","--format=%h %s %ad","--date=iso"]);parts.push(r.stdout.trim()||"(no matching CHECKPOINT commits)")}catch(err){parts.push(`(git log failed: ${err instanceof Error?err.message:String(err)})`)}parts.push(`\u2501\u2501\u2501 END Layer 2 \u2501\u2501\u2501
+`),parts.push("\u2501\u2501\u2501 Layer 3: last 20 commits \u2501\u2501\u2501");try{const r=runner("git",["log","--max-count=20","--format=%h %s %ad","--date=iso"]);parts.push(r.stdout.trim()||"(no commits)")}catch(err){parts.push(`(git log failed: ${err instanceof Error?err.message:String(err)})`)}parts.push(`\u2501\u2501\u2501 END Layer 3 \u2501\u2501\u2501
+`),parts.push("If still unclear, run /clear and reopen with manual MCP context \u2014 feed the issue body, the plan file, and the last few commits to the next session."),process.stdout.write(parts.join(`
+`)+`
+`)}function requirePlanReviewPass(opts){const sanit=sanitizeTaskId(opts.taskId),latestPath=join(planReviewDir(opts.dir,sanit),"latest.json");if(!existsSync(latestPath))return{ok:!1,reason:`no plan-review evidence at ${latestPath} \u2014 record a PASS verdict there first`};let parsed;try{parsed=JSON.parse(readFileTranslated(latestPath,"utf-8"))}catch(err){return{ok:!1,reason:`unreadable latest.json: ${err instanceof Error?err.message:String(err)}`}}return parsed.verdict!=="PASS"?{ok:!1,reason:`last plan-review verdict was ${parsed.verdict}`}:opts.planContent!==void 0&&parsed.planDigest!==void 0&&createHash("sha256").update(opts.planContent).digest("hex")!==parsed.planDigest?{ok:!1,reason:"plan changed since last review \u2014 re-review and update latest.json"}:{ok:!0}}function gateEnabled(dir){return existsSync(join(dir,".arbiter","plan-review.enabled"))}function readGitUserName(){try{return runCli("git",["config","user.name"],{timeoutMs:5e3}).stdout.trim()||"unknown"}catch{return"unknown"}}function writeBypassRecord(dir,sanitisedId,reason){const evDir=planReviewDir(dir,sanitisedId);ensureDir(evDir);const ts=new Date().toISOString(),record={reason,git_user:readGitUserName(),ts};writeFileTranslated(join(evDir,`bypass-${ts.replace(/[:.]/g,"-")}.json`),JSON.stringify(record,null,2))}function loadPlanContentIfAvailable(dir){const planPath=readUnifiedState(dir)?.plan.trim();if(!planPath||planPath.length===0)return;const resolved=join(dir,planPath),candidate=existsSync(planPath)?planPath:existsSync(resolved)?resolved:void 0;if(candidate!==void 0)return readFileTranslated(candidate,"utf-8")}function checkPlanReviewGate(dir,claudeDir,opts){if(!gateEnabled(dir))return;const rawId=readTaskIdFromDisk(dir)??"unknown",sanit=sanitizeTaskId(rawId),inCi=process.env.CI==="true",envBypass=getBoolFlag("ARBITER_SKIP_PLAN_REVIEW");if(opts.skipPlanReview===!0){writeBypassRecord(dir,sanit,"flag"),process.stderr.write(`WARNING: plan-review gate bypassed (reason=flag, --skip-plan-review)
+`);return}if(envBypass&&!inCi){writeBypassRecord(dir,sanit,"env"),process.stderr.write(`WARNING: plan-review gate bypassed (reason=env, ARBITER_SKIP_PLAN_REVIEW=1)
+`);return}const planContent=loadPlanContentIfAvailable(dir),result=requirePlanReviewPass({dir,taskId:rawId,...planContent!==void 0?{planContent}:{}});if(!result.ok){const hint=inCi?"--skip-plan-review (env ARBITER_SKIP_PLAN_REVIEW is refused under CI)":"--skip-plan-review (or env ARBITER_SKIP_PLAN_REVIEW=1)";throw new Error(`plan-review gate: ${result.reason}. Use ${hint} to bypass with an audit record.`)}}function readBranchPrs(branch,dir,candidateSha){const out=runCli("gh",["pr","list","--head",branch,"--state","all","--json","number,state,mergeStateStatus,statusCheckRollup,headRefOid,mergeCommit,mergedAt,baseRefName"],{cwd:dir,timeoutMs:3e4}).stdout,parsed=JSON.parse(out),prs=Array.isArray(parsed)?parsed:[];if(!candidateSha||!prs.some(pr=>pr.state==="MERGED"&&pr.headRefOid===candidateSha))return prs;const checks=readCommitCi(candidateSha,dir);return prs.map(pr=>pr.headRefOid===candidateSha?{...pr,statusCheckRollup:checks}:pr)}const COMMIT_CI_QUERY=`query($owner:String!,$name:String!,$sha:GitObjectID!,$endCursor:String) {
+  repository(owner:$owner,name:$name) { object(oid:$sha) { ... on Commit {
+    statusCheckRollup { contexts(first:100,after:$endCursor) {
+      pageInfo { hasNextPage endCursor }
+      nodes {
+        ... on CheckRun { name conclusion completedAt checkSuite { createdAt branch { name } workflowRun { event } } }
+        ... on StatusContext { context state createdAt }
+      }
+    } }
+  } } }
+}`;function normalizeGraphqlCiCheck(check){const{checkSuite:suite,...rest}=check;if(suite===void 0)return rest;if(suite===null)return{...rest,checkSuite:null};const{branch:graphqlBranch,...suiteRest}=suite,branch=graphqlBranch?.name;return{...rest,checkSuite:{...suiteRest,...branch===void 0?{}:{branch}}}}function readCommitCi(sha,dir){const out=runCli("gh",["api","graphql","--paginate","--slurp","-F","owner={owner}","-F","name={repo}","-f",`sha=${sha}`,"-f",`query=${COMMIT_CI_QUERY}`],{cwd:dir,timeoutMs:3e4}).stdout,contexts=JSON.parse(out).map(page=>page.data.repository.object.statusCheckRollup.contexts);if(contexts.length===0||contexts.some(page=>!Array.isArray(page.nodes)||typeof page.pageInfo.hasNextPage!="boolean")||contexts.at(-1)?.pageInfo.hasNextPage!==!1)throw new Error("Incomplete candidate CI pages");return contexts.flatMap(page=>page.nodes.map(normalizeGraphqlCiCheck))}function prGateRefusal(detail){return new UserFacingError(t("errors.E_PR_NOT_MERGED",{detail}))}function prGateBranch(dir){const branch=detectCurrentBranch(dir)??readUnifiedState(dir)?.branch;if(branch===void 0||branch.length===0)throw prGateRefusal("the current branch could not be determined, so the PR cannot be verified. Pass --no-pr if this repo lands by direct push.");return branch}function prGateSnapshots(dir,branch,opts,candidateSha){try{return opts.readPrs?opts.readPrs(branch,dir):readBranchPrs(branch,dir,candidateSha)}catch(err){throw prGateRefusal(`\`gh pr list --head ${branch}\` failed (${err instanceof Error?err.message:String(err)}). An unverifiable landing is not a landing: fix \`gh\`, or pass --no-pr if this repo lands by direct push.`)}}function prGateSkipped(dir,opts){if(opts.noPr===!0){const rawConfig=readRawArbiterConfig(dir),policy=resolveDirectCompletionPolicy(rawConfig);if(!policy.ok)throw prGateRefusal(policy.reason);if(!hasRawGitHubPermission(rawConfig))throw prGateRefusal("direct post-main CI requires raw permitGitHub: true.");const head=assertDirectHeadOnMain(dir),checks=opts.readCommitCi?.(head,dir)??readCommitCi(head,dir);if(!successfulPostMainCi(checks))throw prGateRefusal("direct post-main CI cannot establish a successful candidate result.");return appendLog(dir,"complete \u2190 no-pr (direct landing)"),!0}return permitsGitHubCalls(dir)?!1:(appendLog(dir,"complete \u2190 pr-check skipped (permitGitHub not set)"),!0)}function assertDirectHeadOnMain(dir){try{const head=runCli("git",["rev-parse","HEAD"],{cwd:dir,timeoutMs:15e3}).stdout.trim(),main=runCli("git",["rev-parse","origin/main"],{cwd:dir,timeoutMs:15e3}).stdout.trim();if(head!==main)throw prGateRefusal("direct landing HEAD does not match current origin/main.");return head}catch(err){throw err instanceof UserFacingError?err:prGateRefusal(`direct landing cannot prove current origin/main (${err instanceof Error?err.message:String(err)}).`)}}function checkPrMergedGate(dir,opts,candidateSha){if(opts.noPr!==!0){const rawConfig=readRawArbiterConfig(dir);if(!hasRawGitHubPermission(rawConfig))throw prGateRefusal("PR completion requires raw permitGitHub: true.");if(candidateSha!==void 0){const policy=resolveEvidenceCompletionPolicy(rawConfig,!0);if(!policy.ok)throw prGateRefusal(policy.reason);if(policy.policy==="direct")throw prGateRefusal("direct completion requires --no-pr.")}}if(prGateSkipped(dir,opts))return;const branch=prGateBranch(dir),snapshots=prGateSnapshots(dir,branch,opts,candidateSha),verdict=candidateSha===void 0?evaluateMerged(snapshots,branch,opts.pr):evaluateHarnessCompletion(dir,snapshots,candidateSha,opts);if(!verdict.merged)throw prGateRefusal(verdict.detail);appendLog(dir,`complete \u2190 PR #${verdict.number} MERGED`)}function evaluateHarnessCompletion(dir,snapshots,candidateSha,opts){const policy=resolveEvidenceCompletionPolicy(readRawArbiterConfig(dir),!0);if(!policy.ok)return{merged:!1,detail:policy.reason};if(policy.policy==="direct")return{merged:!1,detail:"direct completion requires --no-pr."};if(policy.policy==="legacy")return{merged:!1,detail:"evidenceHarness requires an explicit completion policy."};const mergeSha=snapshots.find(pr=>pr.state==="MERGED"&&pr.headRefOid===candidateSha&&pr.mergeCommit?.oid&&(opts.pr===void 0||pr.number===opts.pr))?.mergeCommit?.oid,reachable=mergeSha?opts.isMergeReachable?.(mergeSha,dir)??isMergeReachable(mergeSha,dir):!1;return evaluateMerged(snapshots,"",opts.pr,candidateSha,{policy:policy.policy,mergeReachableFromMain:reachable,requireMainBase:!0})}function isMergeReachable(mergeSha,dir){try{return runCli("git",["merge-base","--is-ancestor",mergeSha,"origin/main"],{cwd:dir,timeoutMs:15e3}),!0}catch{return!1}}function checkCompletionEvidence(dir){const config=loadConfig(dir);if(config?.features.evidenceHarness!==!0){checkGatePassMarkerGate(dir);return}const taskId=readTaskId(dir);if(!taskId)throw new Error("done receipt requires the current task id");const verdict=verifyDoneEvidenceReceipt({root:dir,taskId,archetype:config.archetype??"library",maxAgeMin:getNumberFlag("ARBITER_EVIDENCE_MAX_AGE_MIN")});if(!verdict.ok)throw new Error(verdict.reason);return runCli("git",["rev-parse","HEAD"],{cwd:dir,timeoutMs:15e3}).stdout.trim()}function checkEvidenceCompletionPreflight(dir){if(loadConfig(dir)?.features.evidenceHarness!==!0)return;const policy=resolveEvidenceCompletionPolicy(readRawArbiterConfig(dir),!0);if(!policy.ok)throw new Error(`completion policy: ${policy.reason}`)}function readRawArbiterConfig(dir){try{return JSON.parse(readFileTranslated(join(dir,"arbiter.json"),"utf-8"))}catch(err){throw new Error(`completion policy cannot read raw arbiter.json: ${err instanceof Error?err.message:String(err)}`,{cause:err})}}function hasRawGitHubPermission(rawConfig){return isRecord(rawConfig)&&rawConfig.permitGitHub===!0}function isRecord(value){return typeof value=="object"&&value!==null&&!Array.isArray(value)}function policyRefusal(reason){return{ok:!1,reason}}function resolveExplicitCompletionPolicy(rawConfig){if(!isRecord(rawConfig))return policyRefusal("completion policy requires an object arbiter.json");const policy=explicitPolicy(rawConfig);return policy===void 0?policyRefusal("completion policy requires an explicit supported collaborationMode and merge mode"):hasRawGitHubPermission(rawConfig)?{ok:!0,policy}:policyRefusal("completion requires raw permitGitHub: true")}function explicitPolicy(rawConfig){const mode=rawConfig.collaborationMode;if(mode==="peer-review"||mode==="gated-review")return"reviewed-pr";if(mode!=="trunk-solo"||!isRecord(rawConfig.solo))return;const mergeMode=rawConfig.solo.mergeMode;return mergeMode==="direct"?"direct":mergeMode==="pr-ff"?"exact-pr":void 0}function resolveEvidenceCompletionPolicy(rawConfig,requireExplicit=!1){if(!isRecord(rawConfig))return policyRefusal("completion policy requires an object arbiter.json");const features=rawConfig.features;return isRecord(features)?!requireExplicit&&features.evidenceHarness!==!0?{ok:!0,policy:"legacy"}:resolveExplicitCompletionPolicy(rawConfig):policyRefusal("completion policy requires an object features config")}function resolveDirectCompletionPolicy(rawConfig){const policy=resolveExplicitCompletionPolicy(rawConfig);return policy.ok?policy.policy==="direct"?policy:policyRefusal("`--no-pr` requires raw trunk-solo with solo.mergeMode direct"):policy}function successfulPostMainCi(checks){return checks.every(isSuccessfulPostMainCheck)&&checks.some(check=>check.conclusion==="SUCCESS")}function isSuccessfulPostMainCheck(check){const completed=Date.parse(check.completedAt??""),outcome=check.conclusion??check.state??"";return check.checkSuite?.branch==="main"&&check.checkSuite.workflowRun?.event==="push"&&Number.isFinite(completed)&&completed<=Date.now()&&["SUCCESS","SKIPPED","NEUTRAL"].includes(outcome)}function checkGatePassMarkerGate(dir,minLevel="L2"){const inCi=process.env.CI==="true";if(getBoolFlag("ARBITER_SKIP_GATE_MARKER")&&!inCi){process.stderr.write(`WARNING: gate-pass marker gate bypassed (reason=env, ARBITER_SKIP_GATE_MARKER=1)
+`);return}const markerPath=join(dir,".arbiter","gate-pass.json");if(!existsSync(markerPath))throw new Error(`gate-pass marker missing at ${markerPath}. Run \`node scripts/check-all.mjs ${minLevel}\` first.`);let parsed;try{parsed=JSON.parse(readFileTranslated(markerPath,"utf-8"))}catch(err){throw new Error(`gate-pass marker corrupt at ${markerPath}: ${err instanceof Error?err.message:String(err)}. Run \`node scripts/check-all.mjs ${minLevel}\` first.`,{cause:err})}const verdict=verifyGatePassMarker(parsed,{root:dir,minLevel,maxAgeMin:getNumberFlag("ARBITER_EVIDENCE_MAX_AGE_MIN")});if(!verdict.ok)throw new Error(`${verdict.reason}. Run \`node scripts/check-all.mjs ${minLevel}\` again.`)}export function runTaskAdvance(opts){const dir=opts.dir??process.cwd(),claudeDir=join(dir,".claude"),{to}=opts;if(!isValidPhase(to))throw new Error(`Invalid --to value: "${String(to)}". Valid phases: ${[...PHASE_ORDER,...LATERAL_PHASES].join(", ")}`);const current=currentPhase(dir);if(current===to)return;const isLateralTarget=LATERAL_PHASES.includes(to),isLateralCurrent=LATERAL_PHASES.includes(current);if(!isLateralTarget&&!isLateralCurrent){const currentIdx=PHASE_ORDER.indexOf(current),targetIdx=PHASE_ORDER.indexOf(to);if(targetIdx<currentIdx&&!opts.reverse)throw new Error(`Backward transition "${current}" \u2192 "${to}" blocked. Use --reverse to allow backward transitions.`);if(targetIdx>currentIdx+1)throw new Error(`Illegal skip: cannot advance from "${current}" to "${to}" (missing intermediate phases). Advance one phase at a time.`)}const PLANNING_PHASES=new Set(["red-team-review","red-team-rework"]);({plan:()=>{checkTaskSeededGate(dir),checkEvidenceCompletionPreflight(dir)},"red-team-review":()=>{checkPlanReviewGate(dir,claudeDir,opts)},"red-team-rework":()=>{checkRedTeamEvidenceGate(dir,current,PLANNING_PHASES)},red:()=>{checkAcceptancePlanGate(dir),checkPlanReviewGate(dir,claudeDir,opts),checkRedTeamEvidenceGate(dir,current,PLANNING_PHASES),PLANNING_PHASES.has(current)&&checkHandoffGate(dir,claudeDir,opts)},green:()=>{checkTddEvidenceGate(dir,claudeDir)},refactor:()=>{checkTaskSeededGate(dir)},verification:()=>{checkChainTddEvidenceGate(dir),checkTddEvidenceProvenanceGate(dir)},close:()=>{checkGatePassMarkerGate(dir,"L1")},complete:()=>{const candidateSha=checkCompletionEvidence(dir);checkPrMergedGate(dir,opts,candidateSha)}})[to]?.(),writeUnifiedState(dir,{phase:to}),appendLog(dir,`${current} \u2192 ${to}`)}function checkAcceptancePlanGate(dir){if(!acceptanceProfileEnabled(dir))return;const script=join(dir,"scripts","check-acceptance.mjs");if(!existsSync(script))throw new Error(`acceptance-anchor gate: profile is enabled but ${script} is missing. Restore the emitted checker before entering red.`);const plan=readUnifiedState(dir)?.plan.trim()??"";try{runCli("node",[script,"--plan",plan],{cwd:dir,timeoutMs:5e3})}catch(err){throw new Error(`acceptance-anchor gate: ${err instanceof Error?err.message:String(err)}. The red phase was not entered; restore the emitted checker or repair the anchored Markdown plan.`,{cause:err})}}function acceptanceProfileEnabled(dir){const override=process.env.ARBITER_ACCEPTANCE_ANCHOR;if(override==="1"||override==="true"||override==="0"||override==="false")return getBoolFlag("ARBITER_ACCEPTANCE_ANCHOR");try{return JSON.parse(readFileTranslated(join(dir,"arbiter.json"),"utf-8")).features?.acceptanceAnchor===!0}catch{return!1}}function checkTddEvidenceGate(dir,claudeDir){assertTddEvidenceFor(readTaskIdFromDisk(dir)??"unknown",dir)}function checkTaskSeededGate(dir){const taskId=readTaskIdFromDisk(dir);if(!(taskId!==void 0&&taskId.trim().length>0))throw new Error("task-seed gate: no task id in .claude/.task/status.json \u2014 `preflight` promises seeded task state, and every later evidence gate keys on that id. Run `arbiter task init --id <id> --tier <tier>` first.")}function checkRedTeamEvidenceGate(dir,current,planningPhases){if(!planningPhases.has(current))return;const taskId=readTaskIdFromDisk(dir)??"unknown",path=join(dir,".arbiter","evidence","redteam",`${taskId}.json`);if(!existsSync(path))throw new Error(`red-team evidence gate: no red-team evidence at ${path}. The \`red-team-review\` phase dispatches tier-N red-team agents and records their findings there (see .claude/commands/ship.md \xA7Red-team review) \u2014 record it before advancing.`)}function checkChainTddEvidenceGate(dir){const chainIds=readUnifiedState(dir)?.chainIds??[];if(chainIds.length===0)return;const failures=[];for(const id of chainIds)try{assertTddEvidenceFor(id,dir)}catch(err){failures.push(`  ${id}: ${err.message}`)}if(failures.length>0)throw new Error(`Chain TDD evidence gate: ${failures.length} of ${chainIds.length} chained issue(s) lack valid RED evidence.
+${failures.join(`
+`)}
+Every issue batched onto this branch must have failed a test before it was implemented.`)}function checkTddEvidenceProvenanceGate(dir){const state=readUnifiedState(dir),primary=state?.taskId??"unknown",ids=[primary,...state?.chainIds??[]],failures=[];try{assertTddEvidenceFor(primary,dir)}catch(err){failures.push(`  ${primary}: ${err.message}`)}for(const id of ids)tddEvidenceProducedOnBranch(id,dir)||failures.push(`  ${id}: receipt is not committed on this branch`);if(failures.length!==0)throw new Error(`TDD evidence provenance gate: ${failures.length} failure(s) before verification:
+${failures.join(`
+`)}
+Receipts must be committed and produced on this branch after origin/main. Commit the real RED evidence before entering verification.`)}function assertTddEvidenceFor(rawId,dir){const result=loadTddEvidence(rawId,dir);if(!result.ok)throw new Error(`TDD evidence gate: ${result.reason}. Run \`arbiter task record-red --test-path <path>\` to capture failing test evidence first.`);const ev=result.data;if(ev.task_id!==rawId)throw new Error(`TDD evidence task_id mismatch: evidence has "${ev.task_id}" but active task is "${rawId}".`);if(extractFailureSignature(ev.test_run_log)===null)throw new Error("TDD evidence gate: no recognised failure signature found in test_run_log. The test must actually fail before recording evidence.");const resolved=resolveEvidenceCommit(ev,dir);if(resolved===null)throw new Error(`TDD evidence gate: test_commit_sha "${ev.test_commit_sha}" is not reachable from HEAD. Ensure the test was committed before running \`arbiter task record-red\`, or re-record the evidence after a rebase.`);if("degraded"in resolved)throw new Error(`TDD evidence gate: ${resolved.reason}`);if(!pathExistsInCommit(resolved.sha,ev.test_path,dir))throw new Error(`TDD evidence gate: test_path "${ev.test_path}" not found in commit ${resolved.sha}. Verify the test file was committed at that sha.`)}const INLINE_MAX=10,SUBAGENT_MAX=20,STRATEGY_DESCRIPTION={inline:"Strategy: inline (context is small \u2014 continuing in-context)","sub-agent":"Strategy: sub-agent (medium context \u2014 spawn a sub-agent for the exec phase)",stop:"Strategy: stop (large context \u2014 run /clear then re-invoke to free context)"};export function decideClearStrategy({units,modelSwitch}){return modelSwitch?units===void 0?"stop":units<=INLINE_MAX?"inline":units<=SUBAGENT_MAX?"sub-agent":"stop":"inline"}export function buildHandoffBanner({taskId,strategy,units,tier}){const numericId=taskId.replace(/^#/,""),tierInfo=tier!==void 0?` (tier: ${tier})`:"",unitsInfo=units!==void 0?`, units: ${units}`:"",resumeCmd=`arbiter ship #${numericId} --advance --post-clear`,continueHint=strategy==="inline"?`Continue in this context: run \`${resumeCmd}\` or \`arbiter task advance --to red --post-clear\``:strategy==="sub-agent"?`Spawn a sub-agent for the exec phase, then pass \`--post-clear\` on re-entry:
+  \`${resumeCmd}\``:`1. Run: /clear
+2. Re-invoke: \`${resumeCmd}\``;return["\u2501\u2501\u2501 Plan complete \u2014 handoff required \u2501\u2501\u2501",`Task: ${taskId}${tierInfo}${unitsInfo}`,STRATEGY_DESCRIPTION[strategy],"",continueHint,"","Flag: --post-clear signals post-/clear re-entry (marks task state resumed)."].join(`
+`)}function handlePostClearReEntry(rawId,dir){const existing=readUnifiedState(dir)??{};if(existing.postClearResumed!==void 0)return;if(!(existing.taskId||(rawId!=="unknown"?rawId:void 0)))throw new Error(`Post-clear re-entry: task state has no taskId. Re-initialize the task with \`arbiter task init --id #NNN\` before resuming. (rawId="${rawId}", existing.taskId="${existing.taskId??""}")`);writeUnifiedState(dir,{postClearResumed:new Date().toISOString()})}function checkHandoffGate(dir,claudeDir,opts){const rawId=readTaskIdFromDisk(dir)??"unknown";if(opts.postClear===!0||getBoolFlag("ARBITER_POST_CLEAR")){handlePostClearReEntry(rawId,dir);return}const caps=detectHostCapabilities();if(!caps.modelSwitch){writeUnifiedState(dir,{handoffStrategy:"inline"});return}const strategy=decideClearStrategy({units:opts.units,modelSwitch:caps.modelSwitch});if(strategy==="inline"){writeUnifiedState(dir,{handoffStrategy:"inline"});return}writeUnifiedState(dir,{handoffStrategy:"interactive",handoffReady:!0,planningHandoffReady:new Date().toISOString()});const tier=readUnifiedState(dir)?.tier;throw new HandoffRequiredError(buildHandoffBanner({taskId:rawId,strategy,units:opts.units,tier}))}

package/dist/commands/update.js

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: Apache-2.0
+import{resolve,join}from"node:path";import{acquireLock}from"../utils/file-lock.js";import{UserFacingError,FatalError,ArbiterError}from"../utils/errors.js";import{beginGenerationSession,endGenerationSession,ensureDir}from"../utils/fs.js";import{loadGeneratedManifest,saveGeneratedManifest,manifestKey}from"../state/generated-manifest.js";import{isGateSpineKey,isSafetyClassKey}from"../generators/safety-class.js";import{t}from"../i18n/index.js";import{jsonOutput,statusToExitCode}from"../utils/json-output.js";import{getLogger}from"../utils/logger.js";import{detectAdverseGitState}from"../detectors/git.js";import{detectGithubAccess}from"../detectors/github.js";import{detectLegacyWorkflowCollisionWarning}from"../detectors/workflow-collision.js";import{resolveAxisFields}from"../detectors/axis.js";import{detectInstalledSkills}from"../integrations/skill-detector.js";import{excludeOwnEmittedSkills}from"../generators/skills.js";import{loadConfig,loadSnapshot,saveConfigAndSnapshot}from"../utils/config.js";import{runGithubSetup,printResults,runPlugins,slugifyProjectName}from"./init.js";import{resolveProjectName}from"../config/resolve-project-name.js";import{diffConfig,impactedGenerators}from"../config/diff.js";import{validateConfig}from"../config/schema.js";import{resolveProjectConfig}from"../config/resolve-project-config.js";import{buildRegistry,runGeneratorsFromRegistry,runGeneratorsSelective}from"../generators/registry.js";import{buildAdoptPredicate,recordLocalOverride}from"./adopt-policy.js";import{IGNORE_FILE_NAME,buildSelectionPredicate,loadIgnorePatterns,matchesOnly}from"../config/arbiter-ignore.js";import{applyRetirement,diskHasher,planRetirement,retirementWarning}from"./retire-policy.js";export{buildAdoptPredicate}from"./adopt-policy.js";export function withheldSafetyKeys(results,targetDir){return results.filter(r=>r.withheld===!0&&r.adopted!==!0).map(r=>manifestKey(targetDir,r.path)).filter(k=>k!==null&&(isSafetyClassKey(k)||isGateSpineKey(k)))}function restoredKeys(results,targetDir){return results.filter(r=>r.restored===!0).map(r=>manifestKey(targetDir,r.path)).filter(k=>k!==null).sort((a,b)=>a<b?-1:a>b?1:0)}const RESTORE_REPORT_CAP=20;function detectRestoredFilesWarning(keys){if(keys.length===0)return null;const shown=keys.slice(0,RESTORE_REPORT_CAP),hidden=keys.length-shown.length;return`Warning: restored ${keys.length} file(s) this repository had DELETED after arbiter emitted them \u2014 each has a recorded render baseline in .arbiter-generated-manifest.json but was absent from disk. arbiter re-emits any path it holds a baseline for, so deleting a generated file does not stick, and until now it did not say so. Keep the file and commit it, or make the removal permanent by dropping its entry from the manifest. Restored: ${shown.join(", ")}`+(hidden>0?` (+${hidden} more)`:"")}export function adoptedKeys(results,targetDir){return results.filter(r=>r.withheld===!0&&r.adopted===!0).map(r=>manifestKey(targetDir,r.path)).filter(k=>k!==null)}function printStats(results){const created=results.filter(r=>r.action==="created").length,replaced=results.filter(r=>r.action==="backed-up-and-replaced").length,skipped=results.filter(r=>r.action==="skipped"||r.action==="dry-run").length,withheld=results.filter(r=>r.withheld===!0&&r.adopted!==!0).length;process.stdout.write(`${t("cli.update.done",{created,replaced,skipped,withheld})}
+`)}function isNewlyLandedCheckScript(r){if(r.action!=="created"&&r.action!=="backed-up-and-replaced")return!1;const norm=r.path.replace(/\\/g,"/");return/(^|\/)scripts\/check-[^/]+\.mjs$/.test(norm)}function unwiredGuardResults(results){return results.some(r=>r.withheld===!0&&r.adopted!==!0&&r.path.replace(/\\/g,"/").endsWith("/scripts/check-all.mjs"))?results.filter(isNewlyLandedCheckScript):[]}export function unwiredGuardKeys(results,targetDir){return unwiredGuardResults(results).map(r=>manifestKey(targetDir,r.path)).filter(k=>k!==null)}export function detectUnwiredGateWarning(results){const newGates=unwiredGuardResults(results).map(r=>{const norm=r.path.replace(/\\/g,"/");return norm.slice(norm.lastIndexOf("/")+1)});return newGates.length===0?null:`Warning: ${newGates.join(", ")} added but check-all.mjs is withheld \u2014 the new gate is NOT wired (it will never run). Your check-all.mjs is user-modified, so the template fix that wires it was preserved, not applied. Please re-sync check-all.mjs (delete it and re-run \`arbiter update\`, or manually add the runCheck line) to activate the gate.`}const GATE_INVOKING_WORKFLOWS=["01-pr-fast.yml","06-nightly.yml","drift-shadow.yml"];export function detectGateSignatureWarning(results){return!results.some(r=>r.withheld===!0&&r.path.replace(/\\/g,"/").endsWith("/scripts/check-all.mjs"))||!results.some(r=>{if(r.action!=="created"&&r.action!=="backed-up-and-replaced")return!1;const norm=r.path.replace(/\\/g,"/");return GATE_INVOKING_WORKFLOWS.some(w=>norm.endsWith(`/.github/workflows/${w}`))})?null:"Warning: a CI workflow that invokes `node scripts/check-all.mjs <level> --json <path>` was (re)written but check-all.mjs is withheld (user-modified) \u2014 its arg parser may not match this invocation. Verify your check-all.mjs accepts a POSITIONAL level (`L2`) and `--json [path]`; a parser that reads the level only as `process.argv[2]` or ignores `--json` will silently run the wrong level and write no gate-result artifact while the job stays green (a fake-green). Re-sync check-all.mjs to the template, or update its parser."}function selectAndRun(specs,snapshot,stored,dryRun){const errors=[];if(!snapshot)return{results:runGeneratorsFromRegistry(specs,errors,{dryRun}),keysRun:null,errors};const diff=diffConfig(snapshot,stored);if(diff.paths.length===0)return process.stdout.write(`${t("cli.update.no_config_changes")}
+`),{results:runGeneratorsFromRegistry(specs,errors,{dryRun}),keysRun:null,errors};const keys=impactedGenerators(diff);if(keys.has("*")||keys.size===0){const reason=keys.size===0?"Unknown config change":"Governance/axis change";return process.stdout.write(`${t("cli.update.reason_regen",{reason})}
+`),{results:runGeneratorsFromRegistry(specs,errors,{dryRun}),keysRun:keys,errors}}return keys.add("agents-md"),keys.add("claude"),process.stdout.write(`${t("cli.update.selective",{count:keys.size})}
+`),{results:runGeneratorsSelective(specs,keys,errors,{dryRun}),keysRun:keys,errors}}function selectAndRunWithManifest(specs,snapshot,stored,targetDir,adoptOpts){const prevManifest=loadGeneratedManifest(targetDir);beginGenerationSession({targetDir,prevHashes:prevManifest,adoptPredicate:adoptOpts.adoptPredicate,selectPredicate:adoptOpts.selectPredicate,onAdopt:adoptOpts.onAdopt});const out=selectAndRun(specs,snapshot,stored,!1),generatedHashes=endGenerationSession(),unwired=unwiredGuardKeys(out.results,targetDir),stillWithheldSafety=withheldSafetyKeys(out.results,targetDir),fullRegistryRun=out.keysRun===null||out.keysRun.has("*"),retainedWithheldHashes=Object.fromEntries(out.results.flatMap(result=>{if(!(result.excluded!==void 0)&&(result.withheld!==!0||result.adopted===!0))return[];const key=manifestKey(targetDir,result.path);return key!==null&&prevManifest[key]!==void 0?[[key,prevManifest[key]]]:[]})),nextHashes=fullRegistryRun?{...retainedWithheldHashes,...generatedHashes}:{...prevManifest,...generatedHashes},retirement=planRetirement({prevManifest,results:out.results,targetDir,fullRegistryRun,diskHash:diskHasher(targetDir)});applyRetirement(targetDir,retirement),saveGeneratedManifest(targetDir,nextHashes,unwired,stillWithheldSafety);const report=retirementWarning(retirement);return report!==null&&process.stderr.write(`
+  ${report}
+`),out}function runAdoptPlan(specs,snapshot,stored,targetDir,policy){const prevManifest=loadGeneratedManifest(targetDir),collected=[];beginGenerationSession({targetDir,prevHashes:prevManifest,adoptPredicate:policy.adoptPredicate,selectPredicate:policy.selectPredicate,onAdopt:(key,priorContent,newContent)=>collected.push({key,priorContent,newContent})});let out;try{out=selectAndRun(specs,snapshot,stored,!0)}finally{endGenerationSession()}const retirement=planRetirement({prevManifest,results:out.results,targetDir,fullRegistryRun:out.keysRun===null||out.keysRun.has("*"),diskHash:diskHasher(targetDir)});return{records:collected,results:out.results,retirement}}function summarizeDiff(priorContent,newContent){const oldLines=priorContent.split(`
+`),newLines=newContent.split(`
+`),oldSet=new Map;for(const l of oldLines)oldSet.set(l,(oldSet.get(l)??0)+1);const newSet=new Map;for(const l of newLines)newSet.set(l,(newSet.get(l)??0)+1);let removed=0;for(const[line,count]of oldSet)removed+=Math.max(0,count-(newSet.get(line)??0));let added=0;for(const[line,count]of newSet)added+=Math.max(0,count-(oldSet.get(line)??0));return{removed,added}}function partitionPlanResults(results){return{regenerate:results.filter(r=>(r.action==="replaced"||r.action==="backed-up-and-replaced")&&r.withheld!==!0),withheld:results.filter(r=>r.withheld===!0&&r.adopted!==!0),restore:results.filter(r=>r.restored===!0)}}function printAdoptPlan(records,results,retirement,targetDir,json){const{regenerate,withheld,restore}=partitionPlanResults(results),rel=r=>manifestKey(targetDir,r.path)??r.path;if(json){jsonOutput("update","ok",{adoptPlan:records.map(r=>({path:r.key,...summarizeDiff(r.priorContent,r.newContent)})),wouldRegenerate:regenerate.map(rel),withheld:withheld.map(rel),wouldRestore:restore.map(rel),wouldRetire:retirement.retire,orphans:retirement.orphans,stale:retirement.stale});return}if(retirement.retire.length>0&&process.stdout.write(`
+  would retire ${retirement.retire.length} file(s) (arbiter-owned, no longer emitted, unmodified since arbiter wrote them \u2014 they are DELETED):
+`+retirement.retire.map(k=>`    - ${k}
+`).join("")),records.length===0)process.stdout.write(`
+  adopt-plan: nothing to adopt (no withheld file matches the adopt policy).
+`);else{process.stdout.write(`
+  adopt-plan: ${records.length} file(s) would be adopted:
+`);for(const r of records){const{removed,added}=summarizeDiff(r.priorContent,r.newContent);process.stdout.write(`    - ${r.key}  (-${removed} +${added} lines vs. current on-disk content)
+`)}}if(regenerate.length>0&&(process.stdout.write(`
+  would regenerate ${regenerate.length} file(s) (always-rewrite \u2014 local edits are lost, prior content goes to <file>.arbiter-backup where the generator asks for a backup):
+`),printResults(regenerate,targetDir)),withheld.length>0){process.stdout.write(`
+  would withhold ${withheld.length} file(s) (locally diverged, no adopt policy matches):
+`);for(const r of withheld)process.stdout.write(`    - ${rel(r)}
+`)}if(restore.length>0){process.stdout.write(`
+  would restore ${restore.length} file(s) (arbiter-owned, DELETED from disk since arbiter wrote them \u2014 the run re-emits them):
+`);for(const r of restore)process.stdout.write(`    - ${rel(r)}
+`)}process.stdout.write(`  Re-run without --adopt-plan to apply. Nothing was written.
+`)}function buildNextConfig(stored,axisFields,language,needsMigration,projectName){const{archetype,architectureStyle,isMultiTenant,hasDatabase,databaseEngine,hasPublicApi,contractType,lanes}=axisFields;return{...stored,projectName,archetype,architectureStyle,isMultiTenant,hasDatabase,databaseEngine,hasPublicApi,contractType,language,...lanes.length>0&&{lanes},...needsMigration&&{collaborationMode:"trunk-solo"}}}function detectProjectInfo(targetDir,projectName,stored,options,log){log("  Detecting project...");const arbGhEnv=process.env.ARBITER_GITHUB,envGitHub=arbGhEnv==="1";arbGhEnv!==void 0&&!envGitHub&&process.stderr.write(`Warning: ARBITER_GITHUB=${arbGhEnv} is not '1' \u2014 only ARBITER_GITHUB=1 activates GitHub API calls. Ignored.
+`);const githubAccess=detectGithubAccess();if((options.github||envGitHub)&&!githubAccess.authenticated)throw ArbiterError.fromKey("E_UPDATE_GITHUB_UNAUTHENTICATED","errors.E_UPDATE_GITHUB_UNAUTHENTICATED",{error:githubAccess.error??"gh is not authenticated"});const useGitHub=options.github||envGitHub,{config}=resolveProjectConfig(targetDir,projectName,stored,useGitHub),{language,framework}=config;log(`  \u251C\u2500\u2500 Language: ${language}${framework?` / ${framework}`:""}`),log(`  \u251C\u2500\u2500 Config: tools=[${stored.tools.join(",")}] level=${stored.governanceLevel}`);const axisFields=resolveAxisFields(stored,targetDir,language,framework),claudeHome=process.env.HOME?`${process.env.HOME}/.claude`:"",installedSkills=excludeOwnEmittedSkills(detectInstalledSkills({targetDir,claudeHome})),specs=buildRegistry(config,installedSkills);return{config,specs,useGitHub,axisFields}}function handlePluginError(err,json){const msg=err instanceof Error?err.message:String(err);throw json&&(jsonOutput("update","error",{},[msg],{errorClass:"fatal"}),process.exit(2)),new FatalError("E_PLUGIN_FATAL",msg)}function emitUpdateOutcome(options,summary,generatorErrors,backendWarnings){const generatorErrorLines=generatorErrors.map(e=>`${e.key}: ${e.message}`);if(options.json){emitJsonUpdateOutcome(summary,generatorErrorLines,backendWarnings);return}generatorErrorLines.length>0&&(printGeneratorFailures(generatorErrorLines,backendWarnings),process.exit(statusToExitCode("error"))),backendWarnings.length>0&&(printBackendWarnings(backendWarnings),process.exit(statusToExitCode("warning"))),process.stdout.write(`${t("cli.update.verify_hint")}
+`)}function emitJsonUpdateOutcome(summary,generatorErrorLines,backendWarnings){const status=updateOutcomeStatus(generatorErrorLines,backendWarnings),jsonOpts=jsonOutcomeOpts(status,backendWarnings);jsonOutput("update",status,summary,generatorErrorLines.length>0?generatorErrorLines:void 0,jsonOpts),status!=="ok"&&process.exit(statusToExitCode(status))}function updateOutcomeStatus(generatorErrorLines,backendWarnings){return generatorErrorLines.length>0?"error":backendWarnings.length>0?"warning":"ok"}function jsonOutcomeOpts(status,backendWarnings){if(status==="ok"&&backendWarnings.length===0)return;const jsonOpts={};return backendWarnings.length>0&&(jsonOpts.warnings=backendWarnings),status==="error"&&(jsonOpts.errorClass="fatal"),status==="warning"&&(jsonOpts.errorClass="recoverable"),jsonOpts}function printBackendWarnings(backendWarnings){process.stderr.write(`
+  GitHub warnings (${backendWarnings.length}):
+${backendWarnings.map(w=>`    - ${w}`).join(`
+`)}
+`)}function printGeneratorFailures(generatorErrorLines,backendWarnings){process.stdout.write(`
+  Generator failures (${generatorErrorLines.length}):
+${generatorErrorLines.map(line=>`    - ${line}`).join(`
+`)}
+`),backendWarnings.length>0&&printBackendWarnings(backendWarnings)}function excludedKeys(results,targetDir,kind){return results.filter(r=>r.excluded===kind).map(r=>manifestKey(targetDir,r.path)).filter(k=>k!==null).sort((a,b)=>a<b?-1:a>b?1:0)}function reportSelection(results,targetDir,only,json){const ignored=excludedKeys(results,targetDir,"ignored"),deselected=excludedKeys(results,targetDir,"deselected");if(json)return{ignored,deselected};const conflicted=only.length>0?ignored.filter(k=>matchesOnly(only,k)):[];conflicted.length>0&&process.stdout.write(`
+  --only named ${conflicted.length} file(s) that ${IGNORE_FILE_NAME} also matches; the ignore WINS \u2014 a committed opt-out outranks one run's flag. Not written: ${conflicted.join(", ")}
+`);const onlyMatchedSomething=results.some(r=>{const key=manifestKey(targetDir,r.path);return key!==null&&matchesOnly(only,key)});only.length>0&&!onlyMatchedSomething&&process.stderr.write(`
+  Warning: --only (${only.join(", ")}) matched no managed file \u2014 nothing was written. Patterns match manifest keys; .arbiter-generated-manifest.json lists them.
+`);const ignoredSafety=ignored.filter(k=>isSafetyClassKey(k));return ignoredSafety.length>0&&process.stderr.write(`
+  Note: ${ignoredSafety.length} safety-class file(s) listed in ${IGNORE_FILE_NAME} were not emitted: ${ignoredSafety.join(", ")}
+  They no longer adopt shipped security/enforcement fixes, and the safety-adopt ratchet cannot see them. Remove the pattern to resume enforcement.
+`),{ignored,deselected}}function reportAdoption(results,targetDir,json){const adopted=adoptedKeys(results,targetDir);!json&&adopted.length>0&&process.stdout.write(`
+  Adopted ${adopted.length} safety-class/withheld file(s) (template fix landed over user-modified content; prior content preserved in .arbiter/evidence/local-overrides/):
+`+adopted.map(k=>`    - ${k}
+`).join(""));const stillWithheldSafety=withheldSafetyKeys(results,targetDir);return!json&&stillWithheldSafety.length>0&&process.stderr.write(`
+  Warning: ${stillWithheldSafety.length} protected file(s) remain withheld (user-modified; safety hooks adopt by default \u2014 a gate-spine file adopts only under --adopt-gate-spine): ${stillWithheldSafety.join(", ")}
+  \`scripts/check-safety-adopt-ratchet.mjs\` will FAIL for any of these NOT marked \`arbiter:preserve\` \u2014 re-adopt it, wire the new checks by hand, or mark it.
+`),{adopted,stillWithheldSafety}}function prepareUpdateConfig(targetDir,projectName,stored,options,log){const{config,specs,axisFields}=detectProjectInfo(targetDir,projectName,stored,options,log),snapshot=loadSnapshot(targetDir);log(`
+  Updating...`);const needsMigration=stored.features.soloDevMode===!0&&!stored.collaborationMode;needsMigration&&log("  Migrating soloDevMode=true \u2192 collaborationMode='trunk-solo' (ADR-051)");const nextConfig=buildNextConfig(stored,axisFields,config.language,needsMigration,projectName);return{config,specs,snapshot,nextConfig}}function handleAdverseState(adverseState,force){if(!adverseState)return;const warning=`
+  Warning: ${adverseState.message}
+  ${adverseState.suggestedFix}
+`;if(!force)throw new UserFacingError(`${adverseState.message}
+${adverseState.suggestedFix}
+${t("cli.shared.force_override_hint")}`);getLogger().warn("update.adverse_git_state",{message:adverseState.message,suggested_fix:adverseState.suggestedFix},warning)}function updateLogger(json){return json?()=>{}:msg=>{process.stdout.write(`${msg}
+`)}}function missingConfigResult(options,log){return options.json?jsonOutput("update","error",{},["No arbiter.json found. Run `arbiter init` first."],{errorClass:"config"}):log("  No arbiter.json found. Run `arbiter init` first.\n"),process.exit(78),{keysRun:null}}function saveValidatedConfig(options,nextConfig,targetDir){const validation=validateConfig(nextConfig);if(!validation.ok){options.json?jsonOutput("update","error",{},[`Config invalid after update: ${validation.errors.join("; ")}`]):process.stderr.write(`${t("cli.update.config_invalid",{errors:validation.errors.join("; ")})}
+`),process.exit(2);return}saveConfigAndSnapshot(targetDir,validation.config)}function resolveSelectionPolicy(options,targetDir){const only=options.only??[],ignorePatterns=loadIgnorePatterns(targetDir);return{only,selectPredicate:buildSelectionPredicate({patterns:ignorePatterns,only})}}export async function runUpdate(options){const targetDir=resolve(options.dir??process.cwd()),log=updateLogger(options.json);log(`
+  Arbiter \u2014 update
+`),ensureDir(join(targetDir,".arbiter"));const lock=await acquireLock(join(targetDir,".arbiter",".lock"));try{const stored=loadConfig(targetDir);if(!stored)return missingConfigResult(options,log);const projectName=slugifyProjectName(resolveProjectName(targetDir,stored));handleAdverseState(detectAdverseGitState(targetDir),options.force);const{config,specs,snapshot,nextConfig}=prepareUpdateConfig(targetDir,projectName,stored,options,log),adoptPredicate=buildAdoptPredicate(options),{only,selectPredicate}=resolveSelectionPolicy(options,targetDir);if(options.adoptPlan){const plan=runAdoptPlan(specs,snapshot,nextConfig,targetDir,{adoptPredicate,selectPredicate});return printAdoptPlan(plan.records,plan.results,plan.retirement,targetDir,options.json),{keysRun:null}}const onAdopt=(key,priorContent,newContent)=>{recordLocalOverride(targetDir,{key,priorContent,newContent})},{results,keysRun,errors:generatorErrors}=selectAndRunWithManifest(specs,snapshot,nextConfig,targetDir,{adoptPredicate,selectPredicate,onAdopt}),selection=reportSelection(results,targetDir,only,options.json),pluginResults=await runPlugins(targetDir,Array.isArray(stored.plugins)?stored.plugins:[],stored).catch(err=>handlePluginError(err,options.json));results.push(...pluginResults),options.json||(printResults(results,targetDir),printStats(results));const{adopted,stillWithheldSafety}=reportAdoption(results,targetDir,options.json),backendResult=runGithubSetup(config,log),unwiredWarning=detectUnwiredGateWarning(results),gateSigWarning=detectGateSignatureWarning(results),legacyCollisionWarning=detectLegacyWorkflowCollisionWarning(targetDir),restored=restoredKeys(results,targetDir),restoredWarning=detectRestoredFilesWarning(restored),allWarnings=[...backendResult.warnings,...unwiredWarning?[unwiredWarning]:[],...gateSigWarning?[gateSigWarning]:[],...legacyCollisionWarning?[legacyCollisionWarning]:[],...restoredWarning?[restoredWarning]:[]];saveValidatedConfig(options,nextConfig,targetDir);const summary={created:results.filter(r=>r.action==="created").length,updated:results.filter(r=>r.action==="backed-up-and-replaced").length,skipped:results.filter(r=>r.action==="skipped"||r.action==="dry-run").length,withheld:results.filter(r=>r.withheld===!0&&r.adopted!==!0).length,adopted:adopted.length,withheldSafety:stillWithheldSafety.length,restored:restored.length,ignored:selection.ignored.length,deselected:selection.deselected.length};return emitUpdateOutcome(options,summary,generatorErrors,allWarnings),{keysRun}}finally{endGenerationSession(),await lock.release()}}

package/dist/commands/upgrade-level-interactive.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: Apache-2.0
+import{intro,outro,select,confirm,isCancel,cancel}from"@clack/prompts";import{runUpgradeLevel}from"./upgrade-level.js";const LEVELS=[{value:"L2",label:"L2 \u2014 standard governance (tests, gates, coverage)"}];export async function runInteractiveUpgradeLevel(opts={}){const dir=opts.dir;intro("arbiter upgrade-level");const target=await select({message:"Upgrade to which governance level?",options:LEVELS});if(isCancel(target)){cancel("Cancelled.");return}const proceed=await confirm({message:`Apply upgrade to ${target}?`});if(isCancel(proceed)||!proceed){cancel("Cancelled.");return}outro(`Upgrading to ${target}\u2026`),await runUpgradeLevel({...dir!==void 0?{dir}:{},target,extend:!1,json:!1})}

package/dist/commands/upgrade-level.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync,readFileSync}from"node:fs";import{join,resolve}from"node:path";import{ensureDir,writeFileTranslated}from"../utils/fs.js";import{acquireLock}from"../utils/file-lock.js";import{loadConfig,saveConfig}from"../utils/config.js";import{runCli}from"../utils/run-cli.js";import{getLogger}from"../utils/logger.js";import{jsonOutput}from"../utils/json-output.js";import{validateConfig}from"../config/schema.js";import{ArbiterError}from"../utils/errors.js";import{t}from"../i18n/index.js";const LEVEL_RANK={L1:1,L2:2,L3:3,L4:4},DEFAULT_GRACE_DAYS=30;export const GRACE_MAX_DAYS=35;function clampGraceEndsAt(endsAtMs,nowMs){const maxMs=nowMs+GRACE_MAX_DAYS*864e5;return endsAtMs>maxMs?{ms:maxMs,clamped:!0}:{ms:endsAtMs,clamped:!1}}function resolveGraceWindow(days,nowMs){const{ms,clamped}=clampGraceEndsAt(nowMs+days*864e5,nowMs);return clamped&&process.stderr.write(`${t("cli.upgrade_level.grace_capped",{max:GRACE_MAX_DAYS,requested:days})}
+`),{graceEndsAt:new Date(ms).toISOString(),effectiveDays:clamped?GRACE_MAX_DAYS:days}}function assertValidGraceDays(days){if(days!==void 0&&(!Number.isInteger(days)||days<1))throw new Error(`--days must be a positive integer (>= 1); got "${String(days)}". Example: --days 30.`)}function captureBaselineIfPresent(dir){const baselineScript=join(dir,"scripts","capture-debt-baseline.mjs");if(existsSync(baselineScript))try{runCli("node",["scripts/capture-debt-baseline.mjs","--update"],{cwd:dir})}catch(err){getLogger().warn("upgrade_level.baseline_capture_failed",{err:err instanceof Error?err.message:String(err)},"Baseline capture skipped/failed; re-run after `arbiter update`.")}}function rejectUnsupportedUpgradeTarget(current,target,json){if(current==="L1"&&target==="L2")return!1;const error=ArbiterError.fromKey("E_GRACE_NOT_SUPPORTED","errors.E_GRACE_NOT_SUPPORTED",{},{hint:"To move to a higher level, run `arbiter configure --set governanceLevel=<L3|L4>` followed by `arbiter update`."});if(json)return jsonOutput("upgrade-level","error",{},[error.message]),process.exit(1),!0;throw error}export async function runUpgradeLevel(opts){assertValidGraceDays(opts.days);const dir=resolve(opts.dir??"."),stored=loadConfig(dir);if(!stored){if(opts.json){jsonOutput("upgrade-level","error",{},["No arbiter.json found. Run arbiter init first."]),process.exit(1);return}throw ArbiterError.fromKey("E_CONFIG_NOT_FOUND","errors.E_CONFIG_NOT_FOUND",{},{hint:"Run `arbiter init` to initialize governance in this directory.",docUrl:"https://arbiter.dev/reference/cli#init"})}if(opts.extend){await handleExtend(dir,stored,opts.days??DEFAULT_GRACE_DAYS,opts.json);return}if(!opts.target)throw ArbiterError.fromKey("E_TARGET_REQUIRED","errors.E_TARGET_REQUIRED",{},{hint:"Example: `arbiter upgrade-level --target L2`."});const target=opts.target,current=stored.governanceLevel;if(target===current)throw ArbiterError.fromKey("E_ALREADY_AT_LEVEL","errors.E_ALREADY_AT_LEVEL",{level:current},{hint:"Run `arbiter update` to regenerate governance files at the current level."});if(LEVEL_RANK[target]<LEVEL_RANK[current])throw ArbiterError.fromKey("E_DOWNGRADE_NOT_SUPPORTED","errors.E_DOWNGRADE_NOT_SUPPORTED",{},{hint:"Set `governanceLevel` in arbiter.json to the desired level, then run `arbiter update`."});if(rejectUnsupportedUpgradeTarget(current,target,opts.json))return;const days=opts.days??DEFAULT_GRACE_DAYS,{graceEndsAt,effectiveDays}=resolveGraceWindow(days,Date.now()),upgraded={...stored,governanceLevel:target,graceFromLevel:current,graceEndsAt},validation=validateConfig(upgraded);if(!validation.ok)throw ArbiterError.fromKey("E_CONFIG_INVALID","errors.E_UPGRADE_CONFIG_INVALID",{errors:validation.errors.join("; ")},{hint:"Fix the errors above, or delete arbiter.json and re-run `arbiter init`."});captureBaselineIfPresent(dir),ensureDir(join(dir,".arbiter"));const lock=await acquireLock(join(dir,".arbiter",".lock"));try{await saveConfig(dir,validation.config)}finally{await lock.release()}if(opts.json){jsonOutput("upgrade-level","ok",{from:current,to:target,graceEndsAt,graceDays:effectiveDays});return}const endsDate=graceEndsAt.slice(0,10);process.stdout.write(`${t("cli.upgrade_level.grace_ends_warn",{date:endsDate,days:effectiveDays,target})}
+`)}async function handleExtend(dir,stored,days,json){const existing=stored.graceEndsAt;if(!existing||Date.parse(existing)<=Date.now())throw ArbiterError.fromKey("E_NO_GRACE_PERIOD","errors.E_NO_GRACE_PERIOD",{},{hint:"Run `arbiter upgrade-level --target L2` to start a new grace period."});const _now=Date.now(),{ms:newEndsMs,clamped}=clampGraceEndsAt(Date.parse(existing)+days*864e5,_now);clamped&&process.stderr.write(`${t("cli.upgrade_level.grace_extend_capped",{max:GRACE_MAX_DAYS,requested:days})}
+`);const newEndsAt=new Date(newEndsMs).toISOString(),appliedDays=Math.round((newEndsMs-Date.parse(existing))/864e5),arbiterDir=join(dir,".arbiter");ensureDir(arbiterDir);const logPath=join(arbiterDir,"grace-log.json");let log=[];if(existsSync(logPath)){let raw;try{raw=JSON.parse(readFileSync(logPath,"utf-8"))}catch{throw ArbiterError.fromKey("E_GRACE_LOG_MALFORMED","errors.E_GRACE_LOG_MALFORMED",{path:logPath},{hint:`Delete ${logPath} and retry.`})}if(!Array.isArray(raw))throw ArbiterError.fromKey("E_GRACE_LOG_MALFORMED","errors.E_GRACE_LOG_MALFORMED",{path:logPath},{hint:`Delete ${logPath} and retry.`});log=raw}log.push({action:"extend",at:new Date().toISOString(),previousEndsAt:existing,newEndsAt,days,...clamped?{appliedDays,clampedToMaxDays:GRACE_MAX_DAYS}:{}});const lock=await acquireLock(join(arbiterDir,".lock"));try{writeFileTranslated(logPath,JSON.stringify(log,null,2)+`
+`),await saveConfig(dir,{...stored,graceEndsAt:newEndsAt})}finally{await lock.release()}if(json){jsonOutput("upgrade-level","ok",{action:"extend",newEndsAt,extensionDays:appliedDays});return}const endsDate=newEndsAt.slice(0,10);process.stdout.write(`${t("cli.upgrade_level.grace_extended",{date:endsDate,days:appliedDays})}
+`)}

package/dist/commands/verify-plan.js

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync,readFileSync}from"node:fs";import{ensureDir,writeFileTranslated}from"../utils/fs.js";import{join,resolve}from"node:path";import{PlanJsonV1}from"../types/plan.js";import{runVerify}from"../verify/run.js";import{jsonOutput}from"../utils/json-output.js";function writeErrorReview(pointerDir,taskId,reviewer,ruleId,message){try{ensureDir(pointerDir)}catch(err){process.stderr.write(`[arbiter] could not create pointer dir ${pointerDir}: ${err instanceof Error?err.message:String(err)}
+`);return}const review={timestamp:new Date().toISOString(),task_id:taskId,run_id:"error",status:"ERROR",reviewer,verification:{ok:!1,violations:[{rule_id:ruleId,severity:"ERROR",message,ssot_pointer:null,evidence:{paths:[]}}],notes:[]},blocking:!0,blocking_reason:message};try{writeFileTranslated(join(pointerDir,"REVIEW.json"),JSON.stringify(review,null,2))}catch{}}function reportError(pointerDir,reviewer,ruleId,msg){writeErrorReview(pointerDir,"unknown",reviewer,ruleId,msg)}function parsePlan(planSource){let raw;try{raw=JSON.parse(planSource)}catch(err){return{ok:!1,msg:`invalid JSON: ${err instanceof Error?err.message:String(err)}`,ruleId:"SCHEMA"}}const parsed=PlanJsonV1.safeParse(raw);return parsed.success?{ok:!0,data:parsed.data}:{ok:!1,msg:`schema validation failed: ${parsed.error.issues.map(i=>i.message).join("; ")}`,ruleId:"SCHEMA"}}function emitError(json,filePath,msg){json?jsonOutput("verify plan","error",{file:filePath},[msg]):process.stderr.write(`Error: ${msg}
+`)}function emitVerifyResult(json,result,exitCode,reviewPath){if(json){jsonOutput("verify plan",exitCode===0?"ok":"error",{status:result.status,runId:result.runId,violations:result.review.verification.violations.length,reviewPath,runDir:result.runDir});return}process.stdout.write(`verify plan: ${result.status} (runId=${result.runId}, violations=${result.review.verification.violations.length})
+`);for(const v of result.review.verification.violations)process.stdout.write(`  [${v.severity} ${v.rule_id}] ${v.message}
+`);process.stdout.write(`review: ${reviewPath}
+`)}export function runVerifyPlan(opts){const dir=resolve(opts.dir??"."),filePath=resolve(opts.file),pointerDir=join(dir,".arbiter","plan"),reviewer=opts.reviewer??"bridge-reviewer";if(!existsSync(filePath)){const msg=`plan file not found: ${filePath}`;return reportError(pointerDir,reviewer,"IO",msg),emitError(opts.json,filePath,msg),{exitCode:2,status:"ERROR"}}let planSource;try{planSource=readFileSync(filePath,"utf-8")}catch(err){const msg=`failed to read plan file: ${err instanceof Error?err.message:String(err)}`;return reportError(pointerDir,reviewer,"IO",msg),emitError(opts.json,filePath,msg),{exitCode:2,status:"ERROR"}}const parseResult=parsePlan(planSource);if(!parseResult.ok)return reportError(pointerDir,reviewer,parseResult.ruleId,parseResult.msg),emitError(opts.json,filePath,parseResult.msg),{exitCode:2,status:"ERROR"};const plan=parseResult.data;if(!plan.review_bridge.enabled){const skippedReview={timestamp:new Date().toISOString(),task_id:plan.task_id,run_id:"skipped",status:"SKIPPED",reviewer,verification:{ok:!0,violations:[],notes:["review_bridge.enabled:false"]},blocking:!1,blocking_reason:null};ensureDir(pointerDir);const reviewPath2=join(pointerDir,"REVIEW.json");return writeFileTranslated(join(pointerDir,"PLAN.json"),planSource),writeFileTranslated(reviewPath2,JSON.stringify(skippedReview,null,2)),opts.json?jsonOutput("verify plan","ok",{status:"SKIPPED",reviewPath:reviewPath2}):process.stdout.write(`verify plan: SKIPPED (review_bridge.enabled:false)
+`),{exitCode:0,status:"SKIPPED",reviewPath:reviewPath2}}let result;try{result=runVerify({plan,planSource,targetDir:dir,...opts.reviewer!==void 0?{reviewer:opts.reviewer}:{},...opts.failOnWarn!==void 0?{failOnWarn:opts.failOnWarn}:{},extraRules:opts.extraRules??[]})}catch(err){const msg=`verification engine failed: ${err instanceof Error?err.message:String(err)}`;return reportError(pointerDir,reviewer,"RUNTIME",msg),emitError(opts.json,filePath,msg),{exitCode:2,status:"ERROR"}}const exitCode=result.status==="APPROVED"?0:2,reviewPath=join(result.pointerDir,"REVIEW.json");return emitVerifyResult(opts.json,result,exitCode,reviewPath),{exitCode,status:result.status,runId:result.runId,reviewPath}}

package/dist/commands/verify-tdd.js

@@ -0,0 +1,2 @@
+// SPDX-License-Identifier: Apache-2.0
+import{loadTddEvidence,extractFailureSignature}from"../evidence/tdd.js";import{resolveEvidenceCommit,pathExistsInCommit}from"../evidence/git-checks.js";import{verifyRedExecution}from"../evidence/tdd-reexecute.js";export function runVerifyTdd(opts){const dir=opts.dir??process.cwd(),{taskId}=opts,checks=[],loadResult=loadTddEvidence(taskId,dir);if(!loadResult.ok)return fail(taskId,loadResult.reason,[{name:"evidence-file",pass:!1,reason:loadResult.reason}]);checks.push({name:"evidence-file",pass:!0});const ev=loadResult.data;if(ev.task_id!==taskId){const reason=`task_id mismatch: evidence contains "${ev.task_id}", expected "${taskId}"`;return fail(taskId,reason,[...checks,{name:"task-id-match",pass:!1,reason}])}if(checks.push({name:"task-id-match",pass:!0}),extractFailureSignature(ev.test_run_log)===null){const reason="no recognised failure signature found in test_run_log";return fail(taskId,reason,[...checks,{name:"failure-signature",pass:!1,reason}])}checks.push({name:"failure-signature",pass:!0});const resolved=resolveEvidenceCommit(ev,dir);if(resolved===null){const reason=unresolvedCommitReason(ev);return fail(taskId,reason,[...checks,{name:"sha-on-branch",pass:!1,reason}])}if("degraded"in resolved)return degrade(taskId,resolved.reason,[...checks,{name:"sha-on-branch",pass:!1,reason:resolved.reason}]);const redSha=resolved.sha;if(checks.push(reachableCommitCheck(ev,resolved)),!pathExistsInCommit(redSha,ev.test_path,dir)){const reason=`test_path "${ev.test_path}" not found in commit ${redSha}`;return fail(taskId,reason,[...checks,{name:"test-path-in-commit",pass:!1,reason}])}checks.push({name:"test-path-in-commit",pass:!0});const reExec=verifyRedExecution({...ev,test_commit_sha:redSha},dir);if(!reExec.ok){const reason=reExec.reason??"red-phase re-execution failed";return fail(taskId,reason,[...checks,{name:"red-execution",pass:!1,reason}])}return checks.push({name:"red-execution",pass:!0}),{status:"PASS",exitCode:0,taskId,checks}}function fail(taskId,reason,checks){return{status:"FAIL",exitCode:1,taskId,reason,checks}}function degrade(taskId,reason,checks){return{status:"DEGRADED",exitCode:2,taskId,reason,checks}}function unresolvedCommitReason(ev){const prefix=`test_commit_sha ${ev.test_commit_sha} is not reachable from HEAD`;return ev.test_blob_sha!==void 0?`${prefix} and no commit on this branch carries the recorded RED test content`:`${prefix} and this evidence predates the rebase-stable blob pin \u2014 re-record it with \`arbiter task record-red --test-path ${ev.test_path}\``}function reachableCommitCheck(ev,resolved){return resolved.healed?{name:"sha-on-branch",pass:!0,reason:`pinned sha ${ev.test_commit_sha} was rewritten (rebase) \u2014 resolved to ${resolved.sha} via the recorded RED test blob`}:{name:"sha-on-branch",pass:!0}}

package/dist/commands/verify.js

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync,readdirSync,statSync}from"node:fs";import{appendFileTranslated,ensureDir}from"../utils/fs.js";import{join,resolve}from"node:path";import{runProbes}from"../compatibility/probe.js";import{formatText}from"../compatibility/report.js";import{loadConfig}from"../utils/config.js";import{jsonOutput}from"../utils/json-output.js";import{detectLanguage}from"../detectors/language.js";import{verifySummarySha}from"../risk/sha-check.js";import{classifyPath,highestRisk,UNCLASSIFIED_LEVEL}from"../risk/classifier.js";import{loadSummaryFile}from"../evidence/load.js";import{validateSummarySchema}from"../evidence/summary.js";const FRESHNESS_DAYS=7,MS_PER_DAY=864e5,SKIP_REASON_PATTERN=/^(?:flake|infra|external):#\d+(?::[\w-]+)?$/;function isValidSkipReason(raw){return SKIP_REASON_PATTERN.test(raw)}function writeSkipEntry(dir,reason){const evidenceDir=join(dir,".evidence"),logPath=join(evidenceDir,"skip-log.jsonl");try{ensureDir(evidenceDir),appendFileTranslated(logPath,JSON.stringify({ts:new Date().toISOString(),reason})+`
+`)}catch(err){const errno=err&&typeof err=="object"&&"code"in err?String(err.code):"unknown";throw process.stderr.write(`arbiter verify evidence: refusing to honour E2E_RISK_SKIP \u2014 audit log write failed (${errno}) at ${logPath}
+`),err}}const KNOWN_STACKS=new Set(["typescript","java","kotlin","rust","python","go"]);function resolveStack(summary,dir){const stored=summary.stack;return typeof stored=="string"&&KNOWN_STACKS.has(stored)?stored:detectLanguage(dir)}function classifyFiles(summary,stack){const raw=summary.files;if(!Array.isArray(raw)||raw.length===0)return null;const levels=[];for(const f of raw)typeof f=="string"&&levels.push(classifyPath(f,stack));return levels.length===0?null:highestRisk(levels)}function staleSeverity(level){return level==="R0"||level==="R1"||level==="R2"?{exitCode:2,status:"error"}:{exitCode:1,status:"warning"}}function handleRiskSkip(dir){const skip=process.env.E2E_RISK_SKIP;if(!skip||skip.trim()==="")return null;const trimmed=skip.trim();return isValidSkipReason(trimmed)?(writeSkipEntry(dir,trimmed),process.stderr.write(`arbiter verify evidence: E2E_RISK_SKIP honoured \u2014 reason="${trimmed}" log=${join(dir,".evidence","skip-log.jsonl")}
+`),{status:"ok",exitCode:0,skipped:!0,reason:trimmed}):(process.stderr.write(`arbiter verify evidence: E2E_RISK_SKIP="${trimmed}" rejected \u2014 must match <flake|infra|external>:#<issue>[:<slug>] (e.g. flake:#123). Falling through to normal verification.
+`),null)}function toRunIdCandidate(evidenceDir,name){const candidate=join(evidenceDir,name,"SUMMARY.json");if(!existsSync(candidate))return null;try{return{name,mtimeMs:statSync(join(evidenceDir,name)).mtimeMs,path:candidate}}catch{return null}}function isNewerCandidate(best,next){return best===null?!0:next.mtimeMs!==best.mtimeMs?next.mtimeMs>best.mtimeMs:next.name>best.name}function pickNewestRunIdSummary(evidenceDir,entries){let best=null;for(const name of entries){const candidate=toRunIdCandidate(evidenceDir,name);candidate&&isNewerCandidate(best,candidate)&&(best=candidate)}return best?.path??null}function resolveSummaryPath(dir){const rootPath=join(dir,".evidence","SUMMARY.json");if(existsSync(rootPath))return rootPath;const evidenceDir=join(dir,".evidence");if(!existsSync(evidenceDir))return rootPath;let entries;try{entries=readdirSync(evidenceDir,{withFileTypes:!0}).filter(e=>e.isDirectory()).map(e=>e.name)}catch{return rootPath}return pickNewestRunIdSummary(evidenceDir,entries)??rootPath}function loadSummary(summaryPath){const loaded=loadSummaryFile(summaryPath);return loaded.ok?loaded.body:{status:"error",exitCode:1,reason:loaded.reason}}function isResult(v){return"exitCode"in v&&"status"in v}function makeStaleResult(riskLevel,ageStr){if(riskLevel===null)return{status:"warning",exitCode:1,reason:ageStr};const sev=staleSeverity(riskLevel);return{status:sev.status,exitCode:sev.exitCode,riskLevel,reason:sev.exitCode===2?`${ageStr}; high-risk change set requires fresh evidence`:ageStr}}function checkFreshness(summary,riskLevel){const ts=summary.timestamp;if(typeof ts!="string")return null;const tsMs=Date.parse(ts);if(!Number.isFinite(tsMs))return null;const ageDays=(Date.now()-tsMs)/MS_PER_DAY;if(ageDays<=FRESHNESS_DAYS)return null;const ageStr=`summary is ${ageDays.toFixed(1)} days old (>${FRESHNESS_DAYS})`;return makeStaleResult(riskLevel,ageStr)}export function runVerifyEvidence(opts){const dir=resolve(opts.dir??"."),skipResult=handleRiskSkip(dir);if(skipResult)return skipResult;const summaryPath=resolveSummaryPath(dir),loaded=loadSummary(summaryPath);if(isResult(loaded))return loaded;const shaResult=verifySummarySha(loaded);if(!shaResult.ok)return{status:"error",exitCode:2,reason:shaResult.reason??"sha mismatch"};const schema=validateSummarySchema(loaded);if(!schema.ok)return{status:"error",exitCode:1,reason:schema.errors.join("; ")};const stack=resolveStack(loaded,dir),aggregated=classifyFiles(loaded,stack);if(aggregated===UNCLASSIFIED_LEVEL)return{status:"warning",exitCode:1,riskLevel:aggregated,reason:"one or more files could not be classified \u2014 manual review required"};const riskLevel=aggregated,stale=checkFreshness(loaded,riskLevel);if(stale)return stale;const result={status:"ok",exitCode:0};return riskLevel!==null&&(result.riskLevel=riskLevel),attachProvenance(result,loaded),result}function attachProvenance(result,loaded){loaded.provenance!==void 0&&(result.provenance=loaded.provenance)}export function runVerify(opts){const dir=resolve(opts.dir??"."),report=runProbes(dir);if(opts.json){const cfg=loadConfig(dir),enriched={...report,effectiveConfig:cfg};jsonOutput("validate",report.hasFailures?"error":report.hasWarnings?"warning":"ok",enriched)}else process.stdout.write(formatText(report)+`
+`);report.hasFailures&&process.exit(1)}

package/dist/commands/wizard/coherence.js

@@ -0,0 +1 @@
+import{AUTONOMY_LEVELS}from"../../config/schema.js";import{levelAtLeast}from"../../config/levels.js";const COHERENCE_MATRIX={"trunk-solo":{L1:{severity:"OK",message:""},L2:{severity:"OK",message:""},L3:{severity:"WARN",message:"trunk-solo at L3: no human-approval gate is active. Cosign signatures bind to the dev identity only \u2014 no reviewer attestation. Acceptable under the \xA711.10(k) single-developer exception (ADR-091): arbiter generates the attestation doc, validation-evidence template, and reactivation trigger check (\u22653 authors or EXTERNAL_AUDIT=true \u2192 CI fails, requiring manual switch to CODEOWNERS). See docs/governance/SOLO_DEV_EXCEPTION.md after running arbiter update."},L4:{severity:"CRITICAL",message:"L4 requires CODEOWNERS + human-approval attestation (ADR-050). trunk-solo bypasses both \u2014 the combination is incoherent.",remediation:"Switch collaborationMode to peer-review or gated-review, or downgrade governanceLevel to L3."}},"peer-review":{L1:{severity:"OK",message:""},L2:{severity:"OK",message:""},L3:{severity:"OK",message:""},L4:{severity:"WARN",message:'peer-review at L4: pr-ff merge mode is mandatory (no direct push allowed). If your config sets solo.mergeMode="direct", it will be overridden to "pr-ff".'}},"gated-review":{L1:{severity:"WARN",message:"gated-review at L1: uncommon cell. CODEOWNERS + merge queue overhead is unusual for a lenient governance project. Consider peer-review unless you have specific audit requirements at L1."},L2:{severity:"OK",message:""},L3:{severity:"OK",message:""},L4:{severity:"OK",message:""}}};export function validateCollaborationCoherence(mode,level){const entry=COHERENCE_MATRIX[mode][level];return{valid:entry.severity!=="CRITICAL",severity:entry.severity,message:entry.message,...entry.remediation!==void 0?{remediation:entry.remediation}:{}}}const HEAVY_OVERLAYS=new Set(["pharma","iso27001","regulated"]),MEDIUM_OVERLAYS=new Set(["sox","gdpr","iso9001"]),HEAVY_MIN_LEVEL="L3",MEDIUM_MIN_LEVEL="L2",LEVEL_RANK={L1:1,L2:2,L3:3,L4:4};function belowLevel(level,min){return LEVEL_RANK[level]<LEVEL_RANK[min]}export function validateOverlayCoherence(overlay,level){return HEAVY_OVERLAYS.has(overlay)&&belowLevel(level,HEAVY_MIN_LEVEL)?{valid:!0,severity:"WARN",message:`industryOverlay='${overlay}' is a heavy regulated overlay (audit-trail / security controls) but governanceLevel=${level} does not activate the mutation, evidence-harness, or human-approval gates these controls rely on. The overlay scaffolds the artefacts, but the gate set will not enforce them. Recommended: raise governanceLevel to ${HEAVY_MIN_LEVEL}+ (or downgrade the overlay).`}:MEDIUM_OVERLAYS.has(overlay)&&belowLevel(level,MEDIUM_MIN_LEVEL)?{valid:!0,severity:"WARN",message:`industryOverlay='${overlay}' is a compliance overlay but governanceLevel=${level} does not activate the debt + security-scan gates it complements. Recommended: raise governanceLevel to ${MEDIUM_MIN_LEVEL}+ so the overlay's controls are backed by enforced gates.`}:{valid:!0,severity:"OK",message:""}}export function validateAutonomyCoherence(autonomy,level,hasCi){if(!AUTONOMY_LEVELS.includes(autonomy))return{valid:!0,severity:"WARN",message:`automation.autonomy='${autonomy}' is not a recognized autonomy level (${AUTONOMY_LEVELS.join("|")}) \u2014 run \`arbiter update\` to repair the automation block.`};const a=autonomy;return a==="L3"&&!hasCi?{valid:!1,severity:"CRITICAL",message:"automation.autonomy=L3 (full-auto wave) requires CI: without a red signal the wave cannot verify its own pushes (ADR-093 \xA74).",remediation:"Set automation.autonomy to L2 or lower, or enable CI (add a workflow file under .github/workflows/)."}:level==="L4"&&a==="L3"?{valid:!1,severity:"CRITICAL",message:"governanceLevel=L4 mandates human approval (ADR-050); automation.autonomy=L3 autonomous fix-on-red autopush violates the human-in-loop control.",remediation:"Set automation.autonomy to L2 or lower, or downgrade governanceLevel."}:{valid:!0,severity:"OK",message:""}}export function validateProfileCoherence(maxParallelWorktrees,defaultGateLevel,mode,level){const mpw=typeof maxParallelWorktrees=="number"?maxParallelWorktrees:1;return mpw>1&&mode==="trunk-solo"?{valid:!1,severity:"CRITICAL",message:`automation.maxParallelWorktrees=${mpw} is incoherent with collaborationMode='trunk-solo': a solo-trunk workflow never uses worktrees, so the parallelism can never take effect.`,remediation:"Set automation.maxParallelWorktrees to 1, or switch collaborationMode to peer-review/gated-review."}:defaultGateLevel==="L1"&&levelAtLeast(level,"L3")?{valid:!0,severity:"WARN",message:`automation.defaultGateLevel='L1' under governanceLevel=${level}: the L1 gate skips the coverage, mutation, and evidence gates the rigour tier relies on. Default verification runs leaner than the governance level implies.`}:{valid:!0,severity:"OK",message:""}}const INCOMPATIBLE_LANGUAGE_ARCHETYPES=new Map([["go",new Set(["frontend-spa"])],["java",new Set(["frontend-spa"])],["kotlin",new Set(["frontend-spa"])],["python",new Set(["embedded"])]]);export function validateLanguageArchetypeCoherence(language,archetype){return archetype===void 0?{valid:!0,severity:"OK",message:""}:INCOMPATIBLE_LANGUAGE_ARCHETYPES.get(language)?.has(archetype)===!0?{valid:!0,severity:"WARN",message:`language='${language}' with archetype='${archetype}' is an unusual pairing: arbiter does not scaffold a meaningful ${archetype} toolchain for ${language}. The project will be generated, but the archetype-specific gates and structure will be absent. Recommended: pick an archetype that matches ${language}, or switch language.`}:{valid:!0,severity:"OK",message:""}}export function validateTrunkSoloParityCoherence(mode,wiring){if(mode!=="trunk-solo")return{valid:!0,severity:"OK",message:""};const{hasParityCheck,hasPushGating}=wiring;if(hasParityCheck&&hasPushGating)return{valid:!0,severity:"OK",message:""};const missing=[];return hasParityCheck||missing.push("a local-ci-parity check (run.sh gate full \u2261 CI, INV-59)"),hasPushGating||missing.push("push-gating (the full gate wired to run before push reaches trunk)"),{valid:!1,severity:"CRITICAL",message:`collaborationMode='trunk-solo' is missing ${missing.join(" and ")}. trunk-solo is only sound as 'no PR ceremony, FULL gate locally, CI as verification mirror' \u2014 without both, there is no independent CI net before trunk.`,remediation:"Run `arbiter update` to wire scripts/check-local-ci-parity.mjs and the pre-push hook, or switch collaborationMode to peer-review/gated-review."}}

package/dist/commands/worktree-prune.js

@@ -0,0 +1,4 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync,readFileSync}from"node:fs";import{join}from"node:path";import{runCli}from"../utils/run-cli.js";import{jsonOutput}from"../utils/json-output.js";import{isRunningFromMainRepo,workingTreeDirty,branchFullyMerged}from"../worktree/validate.js";import{isOpenLogEntry,runWorktreeClose}from"./worktree.js";const DEFAULT_STALE_HOURS=24;function readOpenLog(gitRoot){const logPath=join(gitRoot,".arbiter","worktree-open.log.json");if(!existsSync(logPath))return[];try{const raw=JSON.parse(readFileSync(logPath,"utf-8"));return Array.isArray(raw)?raw.filter(isOpenLogEntry):[]}catch{return[]}}function lastCommitIso(branch,gitRoot){try{const out=runCli("git",["log","-1","--format=%cI",branch,"--"],{cwd:gitRoot}).stdout.trim();return out.length>0?out:null}catch{return null}}export function detectPruneCandidates(opts){const now=opts.now??new Date,thresholdMs=opts.staleHours*60*60*1e3,candidates=[],skipped=[];if(!opts.noFetch)try{runCli("git",["fetch","origin"],{cwd:opts.gitRoot,timeoutMs:3e4})}catch{process.stderr.write(`Warning: git fetch failed \u2014 merged checks may use stale refs
+`)}for(const entry of readOpenLog(opts.gitRoot)){const verdict=classifyEntry(entry,opts.gitRoot,now,thresholdMs);verdict.kind==="candidate"?candidates.push(verdict.candidate):skipped.push(verdict.skip)}return{candidates,skipped}}function mergedOrNull(entry,gitRoot){try{return branchFullyMerged(entry.branch,entry.baseBranch,gitRoot,!1)}catch{return null}}function skip(taskId,reason){return{kind:"skip",skip:{taskId,reason}}}function classifyEntry(entry,gitRoot,now,thresholdMs){if(!existsSync(entry.worktreePath))return skip(entry.taskId,"missing-dir");if(workingTreeDirty(entry.worktreePath))return skip(entry.taskId,"dirty");const merged=mergedOrNull(entry,gitRoot);if(merged===null)return skip(entry.taskId,"branch-missing");if(merged)return{kind:"candidate",candidate:{taskId:entry.taskId,worktreePath:entry.worktreePath,branch:entry.branch,reason:"merged",lastActivity:entry.openedAt}};const commitIso=lastCommitIso(entry.branch,gitRoot);if(commitIso===null)return skip(entry.taskId,"branch-missing");const lastActivityMs=Math.max(new Date(entry.openedAt).getTime(),new Date(commitIso).getTime());return now.getTime()-lastActivityMs>thresholdMs?{kind:"candidate",candidate:{taskId:entry.taskId,worktreePath:entry.worktreePath,branch:entry.branch,reason:"inactive",lastActivity:new Date(lastActivityMs).toISOString()}}:skip(entry.taskId,"active")}function executeCandidates(candidates,noFetch,closeFn){const closedIds=[],failed=[];for(const c of candidates){if(workingTreeDirty(c.worktreePath)){failed.push({taskId:c.taskId,error:"tree became dirty between detect and close"});continue}try{closeFn({taskId:c.taskId,noFetch,...c.reason==="inactive"?{force:!0,keepBranch:!0}:{}}),closedIds.push(c.taskId)}catch(err){failed.push({taskId:c.taskId,error:err instanceof Error?err.message:String(err)})}}return{closedIds,failed}}function emitPruneReport(emit,detected,execution,staleHours,execute){emit(`Prune candidates (${detected.candidates.length}), threshold ${staleHours}h:`);for(const c of detected.candidates)emit(`  ${c.reason.padEnd(8)}  ${c.taskId}  ${c.branch}  ${c.worktreePath}`);if(detected.skipped.length>0){emit(`Skipped (${detected.skipped.length}):`);for(const s of detected.skipped)emit(`  ${s.reason.padEnd(13)}  ${s.taskId}`)}if(!execute){emit("Dry-run \u2014 nothing closed. Re-run with --execute to close these worktrees.");return}emit(`Closed ${execution.closedIds.length} worktree(s).`);for(const f of execution.failed)emit(`Failed to close ${f.taskId}: ${f.error}`);if(execution.failed.length>0)throw new Error(`worktree prune: ${execution.failed.length} candidate(s) failed to close`)}export function runWorktreePrune(opts={}){const cwd=opts.cwd??process.cwd(),gitRoot=runCli("git",["rev-parse","--show-toplevel"],{cwd}).stdout.trim()||cwd,emit=opts.onLine??(line=>{process.stdout.write(`${line}
+`)}),closeFn=opts.closeFn??runWorktreeClose,staleHours=opts.staleHours??DEFAULT_STALE_HOURS,noFetch=opts.noFetch??!1,execute=opts.execute??!1;if(!isRunningFromMainRepo(gitRoot))throw new Error("Must run 'worktree prune' from the main repository, not a worktree.");const detected=detectPruneCandidates({gitRoot,staleHours,noFetch,...opts.now!==void 0?{now:opts.now}:{}}),execution=execute?executeCandidates(detected.candidates,noFetch,closeFn):{closedIds:[],failed:[]};if(opts.json){jsonOutput("worktree-prune",execution.failed.length===0?"ok":"error",{dryRun:!execute,staleHours,candidates:detected.candidates,skipped:detected.skipped,closed:execution.closedIds,failed:execution.failed});return}emitPruneReport(emit,detected,execution,staleHours,execute)}

package/dist/commands/worktree.js

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: Apache-2.0
+import{existsSync,readFileSync}from"node:fs";import{ensureDir,renameTranslated,toFsError,writeFileTranslated}from"../utils/fs.js";import{join,resolve}from"node:path";import{runCli,CliError}from"../utils/run-cli.js";import{t}from"../i18n/index.js";import{loadConfig}from"../utils/config.js";import{acquireLock}from"../utils/file-lock.js";import{jsonOutput}from"../utils/json-output.js";import{sanitizeTaskId,branchNameFor,resolveWorktreeBase,worktreePathFor,siblingWorktreePathFor,worktreeDirectoryName}from"../worktree/paths.js";import{materializeLink,checkLinkIntegrity}from"../worktree/links.js";import{harvestFiles}from"../worktree/harvest.js";import{isRunningFromMainRepo,workingTreeDirty,branchFullyMerged}from"../worktree/validate.js";const DEFAULT_LINKS=[{path:".claude/settings.local.json",required:!1},{path:".env",template:".env.example",required:!1},{path:"node_modules",required:!1,type:"directory",strategy:"symlink-children"}];function defaultWorktreeConfig(){return{base:null,links:DEFAULT_LINKS,closeHook:null}}function arbiterLogDir(gitRoot){return join(gitRoot,".arbiter")}function hasLogEntryShape(x){if(typeof x!="object"||x===null)return!1;const e=x;return typeof e.taskId=="string"&&typeof e.worktreePath=="string"&&typeof e.branch=="string"}export function isOpenLogEntry(x){return hasLogEntryShape(x)&&typeof x.openedAt=="string"}export function isCloseLogEntry(x){return hasLogEntryShape(x)&&typeof x.closedAt=="string"}function readJsonArray(path){if(!existsSync(path))return[];try{const raw=JSON.parse(readFileSync(path,"utf-8"));if(!Array.isArray(raw))throw new SyntaxError(`Expected JSON array, got ${typeof raw}`);return raw}catch(err){if(!(err instanceof SyntaxError))throw toFsError(err,path);const ts=new Date().toISOString().replace(/[:.]/g,"-"),backupPath=`${path}.corrupt-${ts}`;let moved=!1,renameErrMsg="";try{renameTranslated(path,backupPath),moved=!0}catch(renameErr){renameErrMsg=renameErr instanceof Error?renameErr.message:String(renameErr)}return process.stderr.write(moved?`Warning: corrupt JSON at ${path} \u2014 moved to ${backupPath}
+`:`Warning: corrupt JSON at ${path} \u2014 could not back up (rename failed: ${renameErrMsg}); original may be overwritten
+`),[]}}function writeJsonArray(path,entries){ensureDir(resolve(path,"..")),writeFileTranslated(path,JSON.stringify(entries,null,2)+`
+`)}function getGitRoot(cwd){return runCli("git",["rev-parse","--show-toplevel"],{cwd}).stdout.trim()}function materializeLinks(specs,gitRoot,worktreePath){const summary={linked:0,linkedDir:0,linkedChildren:0,copied:0,copiedDir:0,missing:0};for(const spec of specs){const result=materializeLink(spec,gitRoot,worktreePath);result.result==="LINKED"?summary.linked++:result.result==="LINKED_DIR"?summary.linkedDir++:result.result==="LINKED_CHILDREN"?summary.linkedChildren++:result.result==="COPIED_TEMPLATE"?summary.copied++:result.result==="COPIED_DIR"?summary.copiedDir++:summary.missing++}return summary}function printLinkSummary(summary){process.stdout.write(`Links:          ${summary.linked} linked, ${summary.linkedDir} linked-dir, ${summary.linkedChildren} linked-children, ${summary.copied} copied-from-template, ${summary.copiedDir} copied-dir, ${summary.missing} missing
+`)}function resolveEffectiveBase(baseBranch,gitRoot){try{return runCli("git",["rev-parse","--verify",`refs/heads/${baseBranch}`],{cwd:gitRoot}),baseBranch}catch(err){if(err instanceof CliError&&!err.notFound&&!err.timedOut)try{return runCli("git",["rev-parse","--verify",`refs/remotes/origin/${baseBranch}`],{cwd:gitRoot}),`origin/${baseBranch}`}catch(innerErr){throw innerErr instanceof CliError&&!innerErr.notFound&&!innerErr.timedOut?new Error(`Base branch '${baseBranch}' does not exist. Create it or specify a different base with --base.`,{cause:innerErr}):innerErr}throw err}}function resolveOpenWorktreePath(opts,gitRoot,worktreeConfig,taskId,slug){if(opts.sibling!==void 0){const siblingSlug=opts.sibling||worktreeDirectoryName(taskId,slug);return siblingWorktreePathFor(gitRoot,siblingSlug)}const worktreeBase=resolveWorktreeBase(gitRoot,worktreeConfig.base,opts.worktreesDir??process.env.ARBITER_WORKTREES_DIR);return worktreePathFor(worktreeBase,taskId,slug)}export async function runWorktreeOpen(opts){const cwd=opts.cwd??process.cwd(),warn=opts.onWarning??(msg=>{process.stdout.write(`${msg}
+`)}),gitRoot=getGitRoot(cwd);if(!isRunningFromMainRepo(gitRoot))throw new Error("Must run from the main repository, not a worktree. The .git entry at this path is a file (gitdir pointer), not a directory.");if(workingTreeDirty(cwd,"exclude"))throw new Error("Working tree has uncommitted changes. Commit or stash your changes before opening a worktree.");const taskId=sanitizeTaskId(opts.taskId),slug=opts.slug,branchName=branchNameFor(taskId,slug),baseBranch=opts.base??"main",wtConfig=loadConfig(gitRoot)?.worktree??defaultWorktreeConfig(),worktreePath=resolveOpenWorktreePath(opts,gitRoot,wtConfig,taskId,slug);if(existsSync(worktreePath))throw new Error(`Worktree already exists at: ${worktreePath}
+Run 'arbiter worktree list' to see open worktrees.`);const effectiveBase=resolveEffectiveBase(baseBranch,gitRoot),baseRef=runCli("git",["rev-parse","--short",effectiveBase],{cwd:gitRoot}).stdout.trim();ensureDir(resolve(worktreePath,"..")),runCli("git",["worktree","add","-b",branchName,worktreePath,effectiveBase],{cwd:gitRoot});const linkSpecs=opts.withBuildLinks?[...wtConfig.links,...wtConfig.buildLinks??[]]:wtConfig.links,linkSummary=materializeLinks(linkSpecs,gitRoot,worktreePath);warnDanglingLinks(linkSpecs,worktreePath,warn);const arbiterDir=arbiterLogDir(gitRoot);ensureDir(arbiterDir);const lock=await acquireLock(join(arbiterDir,".lock"));try{const logPath=join(arbiterDir,"worktree-open.log.json"),entries=readJsonArray(logPath).filter(isOpenLogEntry);entries.push({taskId,slug:slug??null,worktreePath,branch:branchName,baseBranch,baseRef,openedAt:new Date().toISOString()}),writeJsonArray(logPath,entries)}finally{await lock.release()}if(opts.json){jsonOutput("worktree-open","ok",{worktreePath,branch:branchName,baseBranch,baseRef});return}process.stdout.write(`${t("cli.worktree.ready",{path:worktreePath})}
+`),process.stdout.write(`${t("cli.worktree.branch",{branch:branchName})}
+`),process.stdout.write(`${t("cli.worktree.base",{base:baseBranch,ref:baseRef})}
+`),printLinkSummary(linkSummary),process.stdout.write(`${t("cli.worktree.next",{path:worktreePath})}
+`)}function runCloseHookIfConfigured(hookPath,worktreePath,gitRoot,force,warn){if(!hookPath)return;const absPath=resolve(gitRoot,hookPath);if(!existsSync(absPath)){if(!force)throw new Error(`Close hook not found: ${absPath}
+Fix the path in arbiter.json or use --force.`);return}try{runCli(absPath,[resolve(worktreePath)],{timeoutMs:6e4})}catch(err){const msg=err instanceof Error?err.message:String(err);if(!force)throw new Error(`Close hook failed: ${msg}`,{cause:err});warn(`Warning: close hook failed: ${msg}`)}}function deleteTaskBranch(branch,gitRoot,force){try{return runCli("git",["branch","-d",branch],{cwd:gitRoot}),!0}catch(softErr){if(!force)return process.stderr.write(`Warning: could not delete branch '${branch}': ${softErr instanceof Error?softErr.message:String(softErr)}
+`),!1;try{return runCli("git",["branch","-D",branch],{cwd:gitRoot}),!0}catch(hardErr){return process.stderr.write(`Warning: could not force-delete branch '${branch}': ${hardErr instanceof Error?hardErr.message:String(hardErr)}
+`),!1}}}function assertBranchMerged(branch,baseBranch,gitRoot,noFetch,force){if(force)return;if(!branchFullyMerged(branch,baseBranch,gitRoot,!noFetch))throw new Error(`Branch '${branch}' has not been merged into '${baseBranch}'.
+Run '/complete-task' to create and merge the PR first.
+Use --force to close anyway.`)}function harvestAndReport(worktreePath,gitRoot,harvestAll,onHarvestFile){const harvestOpts={worktreePath,mainRepoPath:gitRoot,autoConfirm:harvestAll,captureParentState:!0};onHarvestFile&&(harvestOpts.onFile=onHarvestFile);const result=harvestFiles(harvestOpts);if(result.copied.length>0){process.stdout.write(`${t("cli.worktree.harvested",{count:result.copied.length})}
+`);for(const f of result.copied)process.stdout.write(`${t("cli.worktree.harvest_copied",{file:f})}
+`)}if(result.skipped.length>0){process.stdout.write(`${t("cli.worktree.skipped_count",{count:result.skipped.length})}
+`);for(const f of result.skipped)process.stdout.write(`${t("cli.worktree.harvest_skipped",{file:f})}
+`)}if(result.protectedUntracked.length>0){process.stdout.write(`Protected ${result.protectedUntracked.length} untracked file(s) in main repo from overwrite:
+`);for(const f of result.protectedUntracked)process.stdout.write(`${t("cli.worktree.harvest_protected",{file:f})}
+`)}return result.copied.length+result.skipped.length+result.protectedUntracked.length===0&&process.stdout.write(`${t("cli.worktree.no_harvest")}
+`),result}function validateBeforeClose(params){const{worktreePath,branch,baseBranch,gitRoot,force,harvestAll,noFetch}=params;if(workingTreeDirty(worktreePath)&&!force&&!harvestAll)throw new Error(`Worktree has uncommitted or untracked changes at: ${worktreePath}
+Untracked files also block close to protect never-added work. Commit or stash your changes, then retry. Use --force to close anyway.`);harvestAll?process.stderr.write(`Warning: harvest-all: skipping merge check; any un-merged commits on '${branch}' will be permanently lost.
+`):assertBranchMerged(branch,baseBranch,gitRoot,noFetch,force)}function resolveOpenEntry(logPath,taskId){const openEntries=readJsonArray(logPath).filter(isOpenLogEntry),entry=openEntries.find(e=>e.taskId===taskId&&existsSync(e.worktreePath));if(!entry){const staleIdx=openEntries.findIndex(e=>e.taskId===taskId&&!existsSync(e.worktreePath)),staleEntry=staleIdx!==-1?openEntries[staleIdx]:void 0;throw staleEntry!==void 0&&(process.stderr.write(`Worktree directory missing \u2014 removing stale log entry for task ${taskId} (was: ${staleEntry.worktreePath})
+`),openEntries.splice(staleIdx,1),writeJsonArray(logPath,openEntries)),new Error(`No open worktree found for task ${taskId}. Run 'arbiter worktree list' to see open worktrees.`)}return entry}function warnDanglingLinks(links,worktreePath,warn){for(const d of checkLinkIntegrity(links,worktreePath))warn(`Warning: dangling symlink: ${d}`)}export function runWorktreeClose(opts){const cwd=opts.cwd??process.cwd(),force=opts.force??!1,noFetch=opts.noFetch??!1,harvest=opts.harvest??!1,harvestAll=opts.harvestAll??!1,effectiveForce=force||harvestAll,warn=opts.onWarning??(msg=>{process.stdout.write(`${msg}
+`)}),gitRoot=getGitRoot(cwd);if(!isRunningFromMainRepo(gitRoot))throw new Error("Must run 'worktree close' from the main repository, not a worktree.");const taskId=sanitizeTaskId(opts.taskId),logPath=join(arbiterLogDir(gitRoot),"worktree-open.log.json"),entry=resolveOpenEntry(logPath,taskId),{worktreePath,branch,baseBranch}=entry;let harvestResult=null;(harvest||harvestAll)&&(harvestResult=harvestAndReport(worktreePath,gitRoot,harvestAll,opts.onHarvestFile)),validateBeforeClose({worktreePath,branch,baseBranch,gitRoot,force,harvestAll,noFetch});const wtConfig=loadConfig(gitRoot)?.worktree??defaultWorktreeConfig();warnDanglingLinks(wtConfig.links,worktreePath,warn),runCloseHookIfConfigured(wtConfig.closeHook,worktreePath,gitRoot,effectiveForce,warn),runCli("git",["worktree","remove","--force",worktreePath],{cwd:gitRoot}),runCli("git",["worktree","prune"],{cwd:gitRoot}),opts.keepBranch||deleteTaskBranch(branch,gitRoot,effectiveForce)&&process.stdout.write(`${t("cli.worktree.branch_deleted",{branch})}
+`),writeHarvestAuditIfNeeded(harvestResult,join(arbiterLogDir(gitRoot),"harvest-audit.log.json"),taskId,worktreePath),appendCloseLogEntry(join(arbiterLogDir(gitRoot),"worktree-close.log.json"),{taskId,branch,worktreePath,closedAt:new Date().toISOString(),force:effectiveForce}),emitCloseResult(opts.json,{worktreePath,branch,taskId})}export function runWorktreeRelink(opts){const cwd=opts.cwd??process.cwd(),warn=opts.onWarning??(msg=>{process.stdout.write(`${msg}
+`)}),gitRoot=getGitRoot(cwd);if(!isRunningFromMainRepo(gitRoot))throw new Error("Must run 'worktree relink' from the main repository, not a worktree.");const taskId=sanitizeTaskId(opts.taskId),entry=resolveOpenEntry(join(arbiterLogDir(gitRoot),"worktree-open.log.json"),taskId),wtConfig=loadConfig(gitRoot)?.worktree??defaultWorktreeConfig(),linkSpecs=opts.withBuildLinks?[...wtConfig.links,...wtConfig.buildLinks??[]]:wtConfig.links,linkSummary=materializeLinks(linkSpecs,gitRoot,entry.worktreePath);opts.json?jsonOutput("worktree-relink","ok",{taskId,worktreePath:entry.worktreePath,linkSummary}):(process.stdout.write(`${t("cli.worktree.relinked",{path:entry.worktreePath})}
+`),printLinkSummary(linkSummary)),warnDanglingLinks(linkSpecs,entry.worktreePath,warn)}function appendHarvestAuditEntry(logPath,entry){const entries=readJsonArray(logPath);entries.push(entry),writeJsonArray(logPath,entries)}function writeHarvestAuditIfNeeded(harvestResult,auditLogPath,taskId,worktreePath){harvestResult!==null&&appendHarvestAuditEntry(auditLogPath,{taskId,worktreePath,harvestedAt:new Date().toISOString(),copied:harvestResult.copied,skipped:harvestResult.skipped,protectedUntracked:harvestResult.protectedUntracked,parentBranchBefore:harvestResult.parentBranchBefore,parentUntrackedBefore:harvestResult.parentUntrackedBefore})}function appendCloseLogEntry(logPath,entry){const entries=readJsonArray(logPath).filter(isCloseLogEntry);entries.push(entry),writeJsonArray(logPath,entries)}function emitCloseResult(json,result){if(json){jsonOutput("worktree-close","ok",result);return}process.stdout.write(`${t("cli.worktree.closed",{path:result.worktreePath})}
+`),process.stdout.write(`
+`)}export function runWorktreeList(opts={}){const cwd=opts.cwd??process.cwd(),emit=opts.onLine??(line=>{process.stdout.write(`${line}
+`)}),gitRoot=getGitRoot(cwd),result=runCli("git",["worktree","list","--porcelain"],{cwd:gitRoot}),worktrees=[];let currentPath,currentBranch=null;for(const line of result.stdout.split(`
+`))line.startsWith("worktree ")?(currentPath!==void 0&&worktrees.push({path:currentPath,branch:currentBranch}),currentPath=line.slice(9),currentBranch=null):line.startsWith("branch ")&&(currentBranch=line.slice(7).replace("refs/heads/",""));currentPath!==void 0&&worktrees.push({path:currentPath,branch:currentBranch});const taskWorktrees=worktrees.slice(1).filter(w=>w.branch?.startsWith("task/"));if(opts.json){jsonOutput("worktree-list","ok",{worktrees:taskWorktrees});return}if(taskWorktrees.length===0){emit(`
+No open task worktrees.
+`);return}emit(`
+Open task worktrees (${taskWorktrees.length}):
+`);for(const wt of taskWorktrees)emit(`  ${wt.branch??"(detached)"}  ${wt.path}`);emit("")}