@planu/cli 5.7.4 → 5.7.6

package/dist/tools/package-handoff.js

@@ -1,457 +1,183 @@
-// tools/package-handoff.ts — Handoff context packager tool (SPEC-039)
-import { specStore, knowledgeStore } from '../storage/index.js';
-import { checkSpecReadiness } from '../engine/readiness-checker.js';
-import { packageHandoff } from '../engine/handoff-packager.js';
-import { detectParadigms } from '../engine/paradigm-detector.js';
-import { analyzeContextPreflight, buildTokenWasteReport, loadTokenWastePolicy, recommendRelevantTools, toolsFromPolicyGroups, } from '../engine/token-optimizer/index.js';
-import { appendTransitionEvent } from '../storage/transition-log.js';
-import { formatProjectGraphContext, queryProjectGraphSlice, } from '../engine/project-graph/index.js';
-import { analyzeMinimalImplementation, loadMinimalImplementationPolicy, } from '../engine/minimality/index.js';
-// ── Formatting helpers ───────────────────────────────────────────────────────
-export function formatHandoff(pkg) {
-    const lines = [];
-    lines.push(`# Implementation Handoff Package — ${pkg.specId}`);
-    lines.push('');
-    lines.push(`Generated: ${pkg.generatedAt}`);
-    lines.push(`Readiness Score: ${pkg.readinessScore}/100`);
-    if (pkg.handoffPath) {
-        lines.push(`Handoff Path: ${pkg.handoffPath}`);
-    }
-    if (pkg.contextHash) {
-        lines.push(`Context Hash: ${pkg.contextHash}`);
-    }
-    lines.push(`Blocked: ${pkg.blocked ? 'yes' : 'no'}`);
-    lines.push('');
-    lines.push('## Objective');
-    lines.push('');
-    lines.push(pkg.objective);
-    lines.push('');
-    lines.push('## Acceptance Criteria');
-    lines.push('');
-    if (pkg.criteria.length > 0) {
-        for (const criterion of pkg.criteria) {
-            lines.push(`- [ ] ${criterion}`);
+// tools/package-handoff.ts — Handoff context packager tool (SPEC-039, durable submission SPEC-1240)
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
         }
-    }
-    else {
-        lines.push('_(No criteria found — check spec.md acceptance criteria)_');
-    }
-    lines.push('');
-    lines.push('## Files to Modify');
-    lines.push('');
-    if (pkg.filesToModify.length > 0) {
-        for (const f of pkg.filesToModify) {
-            lines.push(`- ${f}`);
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
         }
-    }
-    else {
-        lines.push('_(No files identified — check spec.md ## Technical / ## Files)_');
-    }
-    lines.push('');
-    lines.push('## Files to Create');
-    lines.push('');
-    if (pkg.filesToCreate.length > 0) {
-        for (const f of pkg.filesToCreate) {
-            lines.push(`- ${f}`);
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
         }
-    }
-    else {
-        lines.push('_(None identified)_');
-    }
-    lines.push('');
-    lines.push('## Test Files');
-    lines.push('');
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- compat guard: callers may construct a HandoffPackage object predating this field
-    const filesToTest = pkg.filesToTest ?? [];
-    if (filesToTest.length > 0) {
-        for (const f of filesToTest) {
-            lines.push(`- ${f}`);
-        }
-    }
-    else {
-        lines.push('_(None identified)_');
-    }
-    lines.push('');
-    lines.push('## Ownership');
-    lines.push('');
-    if (pkg.ownership.length > 0) {
-        for (const item of pkg.ownership) {
-            lines.push(`- ${item}`);
-        }
-    }
-    else {
-        lines.push('_(Missing ownership — handoff is blocked)_');
-    }
-    lines.push('');
-    lines.push('## Test Plan');
-    lines.push('');
-    if (pkg.testPlan.length > 0) {
-        for (const item of pkg.testPlan) {
-            lines.push(`- ${item}`);
-        }
-    }
-    else {
-        lines.push('_(Missing test plan — handoff is blocked)_');
-    }
-    lines.push('');
-    lines.push('## Risks');
-    lines.push('');
-    if (pkg.risks.length > 0) {
-        for (const item of pkg.risks) {
-            lines.push(`- ${item}`);
-        }
-    }
-    else {
-        lines.push('_(Missing risk analysis — handoff is blocked)_');
-    }
-    lines.push('');
-    lines.push('## OUT OF SCOPE');
-    lines.push('');
-    lines.push('**The following must NOT be implemented:**');
-    lines.push('');
-    for (const item of pkg.outOfScope) {
-        lines.push(`- ${item}`);
-    }
-    lines.push('');
-    if (pkg.constraints.length > 0) {
-        lines.push('## Hard Constraints');
-        lines.push('');
-        for (const constraint of pkg.constraints) {
-            lines.push(`- [${constraint.type.toUpperCase()}] ${constraint.description}`);
-            if (constraint.affectedItems.length > 0) {
-                lines.push(`  Affects: ${constraint.affectedItems.join(', ')}`);
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
             }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
         }
-        lines.push('');
-    }
-    if (pkg.warnings.length > 0) {
-        lines.push('## Warnings');
-        lines.push('');
-        for (const warning of pkg.warnings) {
-            lines.push(`- WARNING: ${warning}`);
-        }
-        lines.push('');
-    }
-    lines.push('## Current State');
-    lines.push('');
-    lines.push(pkg.currentState);
-    lines.push('');
-    lines.push('## Next Action');
-    lines.push('');
-    lines.push(pkg.nextAction);
-    lines.push('');
-    if (pkg.blockers.length > 0) {
-        lines.push('## Blockers');
-        lines.push('');
-        for (const blocker of pkg.blockers) {
-            lines.push(`- ${blocker}`);
-        }
-        lines.push('');
-    }
-    return lines.join('\n');
-}
-function topItems(items, limit) {
-    return items.slice(0, limit);
-}
-function buildHandoffSummaryText(args) {
-    const lines = [];
-    lines.push(`# Implementation Handoff Package - ${args.pkg.specId}`);
-    lines.push('');
-    lines.push(`Readiness Score: ${String(args.pkg.readinessScore)}/100`);
-    lines.push(`Blocked: ${args.pkg.blocked ? 'yes' : 'no'}`);
-    if (args.pkg.handoffPath) {
-        lines.push(`Handoff Path: ${args.pkg.handoffPath}`);
-    }
-    if (args.pkg.contextHash) {
-        lines.push(`Context Hash: ${args.pkg.contextHash}`);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- compat guard: callers may construct a HandoffPackage object predating this field
-    const filesToTestCount = (args.pkg.filesToTest ?? []).length;
-    lines.push(`Counts: ${String(args.pkg.criteria.length)} criteria, ${String(args.pkg.filesToModify.length)} files to modify, ${String(args.pkg.filesToCreate.length)} files to create, ${String(filesToTestCount)} files to test, ${String(args.pkg.testPlan.length)} tests, ${String(args.pkg.risks.length)} risks.`);
-    if (args.topBlockers.length > 0) {
-        lines.push(`Top blockers: ${args.topBlockers.join('; ')}`);
-    }
-    if (args.topRisks.length > 0) {
-        lines.push(`Top risks: ${args.topRisks.join('; ')}`);
-    }
-    if (args.minimalityBlocked !== null) {
-        lines.push(`Minimality: ${args.minimalityBlocked ? 'blocked' : 'pass'}`);
-    }
-    if (args.tokenWasteRiskCount !== null) {
-        lines.push(`Token Waste Autopilot risks: ${String(args.tokenWasteRiskCount)}`);
-    }
-    lines.push(`Next Action: ${args.pkg.nextAction}`);
-    lines.push('');
-    lines.push('Full handoff is available via the handoffPath artifact; it is not embedded by default.');
-    return lines.join('\n');
-}
-function summarizeMinimality(report) {
-    if (report === null) {
-        return undefined;
-    }
-    const blockingFindings = report.findings.filter((finding) => finding.blocksDone);
-    return {
-        enabled: report.enabled,
-        blocked: report.blocked,
-        findingCount: report.findings.length,
-        blockingFindingCount: blockingFindings.length,
-        blockersTop3: topItems(blockingFindings, 3).map((finding) => ({
-            ruleId: finding.ruleId,
-            target: finding.target,
-            evidence: finding.evidence,
-        })),
-        safetyExceptionCount: report.safetyExceptions.length,
-        debtEvidenceCount: report.debtEvidence.length,
+        return next();
     };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { createHash } from 'node:crypto';
+import { specStore } from '../storage/index.js';
+import { DurableJobRuntime, DurableJobNotFoundError, publicJobCursor, } from '../engine/execution/job-runtime.js';
+import { schedulePackageHandoffJobExecution } from '../engine/execution/package-handoff-job-executor.js';
+import { acquireLock, releaseLock } from '../engine/safety/cross-process-lock.js';
+import { resolveProjectId, missingProjectIdError } from './resolve-project-id.js';
+export { formatHandoff } from '../engine/handoff-format.js';
+const SUBMISSION_LOCK_WAIT_MS = 5_000;
+const SUBMISSION_LOCK_POLL_MS = 100;
+const TERMINAL_RECOVERABLE_STATES = new Set(['failed', 'cancelled', 'dead-letter']);
+function deriveOperationId(projectId, specId, specVersion) {
+    const digest = createHash('sha256').update(`${projectId}|${specId}|${specVersion}`).digest('hex');
+    return `handoff-${digest}`;
 }
-function summarizeTokenWaste(report) {
-    if (report === null) {
-        return undefined;
-    }
-    return {
-        actionsTakenCount: report.actionsTaken.length,
-        recommendationCount: report.recommendations.length,
-        riskCount: report.risks.length,
-        risksTop3: topItems(report.risks, 3).map((risk) => ({
-            decision: risk.decision,
-            target: risk.target,
-            reason: risk.reason,
-            confidence: risk.confidence,
-        })),
-        modelEffort: {
-            effort: report.modelEffort.effort,
-            reason: report.modelEffort.reason,
-        },
-    };
-}
-function summarizeGraphContext(graphContext) {
-    if (graphContext === null || typeof graphContext !== 'object') {
-        return { available: false };
-    }
-    const graph = graphContext;
-    return {
-        available: true,
-        nodeCount: Array.isArray(graph.nodes) ? graph.nodes.length : 0,
-        edgeCount: Array.isArray(graph.edges) ? graph.edges.length : 0,
-        summary: graph.summary,
-        tokenSavings: graph.tokenSavings,
-        freshness: graph.freshness
-            ? {
-                graphPath: graph.freshness.graphPath,
-                stale: graph.freshness.stale,
-                reason: graph.freshness.reason,
-            }
-            : undefined,
-    };
-}
-async function buildHandoffTokenWasteReport(pkg, knowledge, spec) {
-    try {
-        const { policy } = await loadTokenWastePolicy(knowledge.projectPath);
-        if (!policy.enabled) {
-            return null;
-        }
-        const context = analyzeContextPreflight({
-            action: 'package_handoff',
-            policy,
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- compat guard: callers may construct a HandoffPackage object predating this field
-            candidates: [...pkg.filesToModify, ...pkg.filesToCreate, ...(pkg.filesToTest ?? [])].map((path) => ({
-                path,
-                reason: 'Referenced by handoff package.',
-            })),
-            spec: {
-                id: spec.id,
-                risk: spec.risk,
-                target: spec.target,
-            },
+async function acquireSubmissionLock(projectId, operationId) {
+    const deadlineAt = Date.now() + SUBMISSION_LOCK_WAIT_MS;
+    while (Date.now() < deadlineAt) {
+        const handle = await acquireLock(projectId, `${operationId}-submit`, {
+            reason: 'durable-handoff-submit',
         });
-        const tools = recommendRelevantTools({
-            action: 'package_handoff',
-            intentSignals: ['handoff', spec.scope ?? '', spec.target ?? ''].filter(Boolean),
-            tools: toolsFromPolicyGroups(policy),
-            policy,
-        });
-        return buildTokenWasteReport({
-            action: 'package_handoff',
-            policy,
-            context,
-            tools,
-            spec: {
-                id: spec.id,
-                risk: spec.risk,
-                scope: spec.scope,
-            },
-        });
-    }
-    catch {
-        return null;
-    }
-}
-async function buildGraphContextSection(args) {
-    if (args.projectPath === undefined) {
-        return null;
-    }
-    try {
-        const slice = await queryProjectGraphSlice({
-            projectId: args.projectId,
-            projectPath: args.projectPath,
-            specId: args.specId,
-        });
-        if (slice === null || slice.nodes.length === 0) {
-            return null;
+        if (handle) {
+            return handle;
+        }
+        const remainingMs = deadlineAt - Date.now();
+        if (remainingMs > 0) {
+            await new Promise((resolve) => setTimeout(resolve, Math.min(SUBMISSION_LOCK_POLL_MS, remainingMs)));
         }
-        return { text: await formatProjectGraphContext(slice), structured: slice };
-    }
-    catch {
-        return null;
-    }
-}
-async function buildMinimalImplementationReport(pkg, knowledge, spec, handoffText) {
-    try {
-        const { policy, evidence } = await loadMinimalImplementationPolicy(knowledge.projectPath);
-        return analyzeMinimalImplementation({
-            policy,
-            specId: spec.id,
-            specRisk: spec.risk,
-            handoffText,
-            // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- compat guard: callers may construct a HandoffPackage object predating this field
-            files: [...pkg.filesToModify, ...pkg.filesToCreate, ...(pkg.filesToTest ?? [])].map((path) => ({ path, content: path })),
-            evidence,
-        });
-    }
-    catch {
-        return null;
     }
+    throw new Error('[Planu] Timed out waiting for the package_handoff submission lock');
 }
-// ── Handler ──────────────────────────────────────────────────────────────────
+/** Public MCP boundary: submit the handoff job and acknowledge without packaging inline. */
 export async function handlePackageHandoff(args) {
-    const { projectId, specId } = args;
-    const spec = await specStore.getSpec(projectId, specId);
-    if (!spec) {
-        return {
-            content: [
-                {
-                    type: 'text',
-                    text: `Spec '${specId}' not found in project '${projectId}'`,
-                },
-            ],
-            isError: true,
-        };
+    const projectId = resolveProjectId(args);
+    if (!projectId) {
+        return missingProjectIdError;
     }
-    const knowledge = await knowledgeStore.getKnowledge(projectId);
-    if (!knowledge) {
+    const { specId } = args;
+    const spec = await specStore.getSpec(projectId, specId, args.projectPath);
+    if (!spec) {
         return {
             content: [
-                {
-                    type: 'text',
-                    text: `Project '${projectId}' not found. Run init_project first.`,
-                },
+                { type: 'text', text: `Spec '${specId}' not found in project '${projectId}'` },
             ],
             isError: true,
+            structuredContent: { error: 'spec_not_found', code: 404, context: { specId, projectId } },
         };
     }
-    // Run readiness check to populate score
-    const readinessReport = await checkSpecReadiness(spec, 'lenient');
-    const pkg = await packageHandoff(spec, knowledge);
-    // SPEC-035b: Inject paradigm constraint when project path is available
-    const paradigmConstraints = pkg.constraints.slice();
-    if (knowledge.projectPath) {
+    const specVersion = spec.spec_version ?? '0.0.0';
+    const operationId = deriveOperationId(projectId, specId, specVersion);
+    const submissionLock = await acquireSubmissionLock(projectId, operationId);
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
         try {
-            const paradigmReport = await detectParadigms(knowledge.projectPath);
-            const dominant = paradigmReport.dominant;
-            if (dominant && dominant.confidence >= 0.5) {
-                paradigmConstraints.push({
-                    type: 'interface',
-                    description: `Follow ${dominant.name} paradigm patterns — dominant paradigm (confidence: ${(dominant.confidence * 100).toFixed(0)}%)`,
-                    affectedItems: ['all new code'],
+            const runtime = __addDisposableResource(env_1, new DurableJobRuntime(), false);
+            let existing;
+            try {
+                existing = runtime.get({ operationId, projectId });
+            }
+            catch (error) {
+                if (!(error instanceof DurableJobNotFoundError)) {
+                    throw error;
+                }
+            }
+            if (existing && !TERMINAL_RECOVERABLE_STATES.has(existing.state)) {
+                if (existing.state === 'accepted' || existing.state === 'checkpointed') {
+                    schedulePackageHandoffJobExecution(projectId, existing.workspaceId);
+                }
+                return acceptedResult(existing, projectId, runtime, { justCreated: false });
+            }
+            if (existing && TERMINAL_RECOVERABLE_STATES.has(existing.state)) {
+                return acceptedResult(existing, projectId, runtime, {
+                    justCreated: false,
+                    recoveryAction: 'restart_job',
                 });
             }
+            const job = runtime.accept({
+                projectId,
+                operationId,
+                payload: {
+                    kind: 'package-handoff',
+                    schemaVersion: 1,
+                    projectId,
+                    specId,
+                    specVersion,
+                },
+            });
+            schedulePackageHandoffJobExecution(projectId, job.workspaceId);
+            return acceptedResult(job, projectId, runtime, { justCreated: true });
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
         }
-        catch {
-            // Paradigm detection is best-effort — never block handoff
+        finally {
+            __disposeResources(env_1);
         }
     }
-    // Inject readiness score
-    const pkgWithScore = {
-        ...pkg,
-        readinessScore: readinessReport.score,
-        constraints: paradigmConstraints,
-    };
-    const tokenWasteReport = await buildHandoffTokenWasteReport(pkgWithScore, knowledge, spec);
-    const graphContext = await buildGraphContextSection({
-        projectId,
-        projectPath: knowledge.projectPath,
-        specId,
-    });
-    const baseHandoffText = graphContext !== null
-        ? `${formatHandoff(pkgWithScore)}\n${graphContext.text}`
-        : formatHandoff(pkgWithScore);
-    const minimalityReport = await buildMinimalImplementationReport(pkgWithScore, knowledge, spec, baseHandoffText);
-    void appendTransitionEvent({
+    finally {
+        await releaseLock(submissionLock);
+    }
+}
+function acceptedResult(job, projectId, runtime, { justCreated, recoveryAction }) {
+    const observation = runtime.observe(job);
+    const accepted = {
+        schemaVersion: 1,
+        operationId: job.id,
         projectId,
-        specId,
-        eventType: 'handoff.intake',
-        gateResults: { handoff: pkgWithScore.blocked ? 'fail' : 'pass' },
-        meta: {
-            handoffPath: pkgWithScore.handoffPath,
-            contextHash: pkgWithScore.contextHash,
-            blockers: pkgWithScore.blockers,
-        },
-    }).catch(() => {
-        /* best-effort — handoff rendering should not fail because telemetry failed */
-    });
-    const topBlockers = topItems(pkgWithScore.blockers, 3);
-    const ownershipBlockers = pkgWithScore.blockers.filter((blocker) => blocker.startsWith('handoff_ownership_invalid'));
-    const topRisks = topItems(pkgWithScore.risks, 5);
-    const minimalitySummary = summarizeMinimality(minimalityReport);
-    const tokenWasteSummary = summarizeTokenWaste(tokenWasteReport);
-    const graphSummary = graphContext !== null ? summarizeGraphContext(graphContext.structured) : undefined;
+        workspaceId: job.workspaceId,
+        state: job.state,
+        submittedAt: justCreated ? job.updatedAt : job.createdAt,
+        attachedAt: justCreated ? job.updatedAt : new Date().toISOString(),
+        reused: !justCreated,
+        cursor: publicJobCursor(observation),
+        queue: observation.queue,
+        terminalStates: ['completed', 'failed', 'cancelled', 'dead-letter'],
+        resultSchema: 'package-handoff-completion/v1',
+        observation: { get: 'get_job', restart: 'restart_job' },
+        ...(recoveryAction ? { recoveryAction } : {}),
+    };
+    const text = recoveryAction
+        ? `Handoff job ${job.id} ended as ${job.state}. Call restart_job to retry, or resubmit package_handoff once fixed.`
+        : justCreated
+            ? `Handoff accepted as durable job ${job.id}.`
+            : `Attached to already-running handoff job ${job.id}; no new work was scheduled. Follow it with get_job.`;
     return {
-        content: [
-            {
-                type: 'text',
-                text: buildHandoffSummaryText({
-                    pkg: pkgWithScore,
-                    topBlockers,
-                    topRisks,
-                    minimalityBlocked: minimalityReport?.blocked ?? null,
-                    tokenWasteRiskCount: tokenWasteReport?.risks.length ?? null,
-                }),
-            },
-        ],
-        structuredContent: {
-            specId,
-            blocked: pkgWithScore.blocked,
-            readinessScore: pkgWithScore.readinessScore,
-            blockersCount: pkgWithScore.blockers.length,
-            blockersTop3: topBlockers,
-            ownershipBlockers,
-            risksTop5: topRisks,
-            criteriaTop5: topItems(pkgWithScore.criteria, 5),
-            constraintsTop5: topItems(pkgWithScore.constraints, 5),
-            warningsTop5: topItems(pkgWithScore.warnings, 5),
-            handoffPath: pkgWithScore.handoffPath,
-            contextHash: pkgWithScore.contextHash,
-            artifactRefs: {
-                handoff: pkgWithScore.handoffPath,
-            },
-            counts: {
-                criteria: pkgWithScore.criteria.length,
-                filesToModify: pkgWithScore.filesToModify.length,
-                filesToCreate: pkgWithScore.filesToCreate.length,
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- compat guard: callers may construct a HandoffPackage object predating this field
-                filesToTest: (pkgWithScore.filesToTest ?? []).length,
-                ownership: pkgWithScore.ownership.length,
-                testPlan: pkgWithScore.testPlan.length,
-                risks: pkgWithScore.risks.length,
-                constraints: pkgWithScore.constraints.length,
-                warnings: pkgWithScore.warnings.length,
-                outOfScope: pkgWithScore.outOfScope.length,
-            },
-            nextAction: pkgWithScore.nextAction,
-            ...(minimalitySummary !== undefined ? { minimality: minimalitySummary } : {}),
-            ...(tokenWasteSummary !== undefined ? { tokenWaste: tokenWasteSummary } : {}),
-            ...(graphSummary !== undefined ? { graphContext: graphSummary } : {}),
-        },
+        content: [{ type: 'text', text }],
+        structuredContent: accepted,
     };
 }
 //# sourceMappingURL=package-handoff.js.map

package/dist/tools/reconcile-session-safeguard-hook.js

@@ -60,21 +60,28 @@ async function installHookFile(projectPath) {
                 '{',
                 '  echo "[$(date -u +%FT%TZ)] session-safeguard fired"',
                 '  cd "${CLAUDE_PROJECT_DIR:-.}" || exit 0',
-                '  current=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
-                '  case "$current" in',
-                '    ""|HEAD|main|master|develop|release|production)',
-                '      # SPEC-1379: never autopush protected branches — mirrors PROTECTED_BRANCHES',
-                '      # in src/engine/session-safeguard/autopush.ts. --no-verify below is safe',
-                '      # ONLY because of this guard; remove one, remove both.',
-                '      echo "skip: protected or detached ($current)"',
-                '      ;;',
-                '    *)',
-                '      # No --force: the remote rejects any non-fast-forward push, so this can',
-                '      # never overwrite remote history. --end-of-options hardens against',
-                '      # refnames that start with a dash.',
-                '      git push --no-verify --end-of-options origin "$current" 2>&1 || echo "push failed or nothing to push"',
-                '      ;;',
-                '  esac',
+                '  if [ -n "${PLANU_NO_AUTOPUSH:-}" ] || [ -f "${CLAUDE_PROJECT_DIR:-.}/.claude/no-autopush" ]; then',
+                '    echo "skip: autopush opt-out active"',
+                '  else',
+                '    current=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "")',
+                '    case "$current" in',
+                '      ""|HEAD|main|master|develop|release|production)',
+                '        # SPEC-1379: never autopush protected branches — mirrors PROTECTED_BRANCHES',
+                '        # in src/engine/session-safeguard/autopush.ts.',
+                '        echo "skip: protected or detached ($current)"',
+                '        ;;',
+                '      *)',
+                '        if git rev-parse --verify --quiet "refs/remotes/origin/$current" >/dev/null; then',
+                '          # No --force: the remote rejects any non-fast-forward push, so this can',
+                '          # never overwrite remote history. --end-of-options hardens against',
+                '          # refnames that start with a dash.',
+                '          git push --end-of-options origin "$current" 2>&1 || echo "push failed or nothing to push"',
+                '        else',
+                '          echo "skip: no upstream for $current (no-upstream)"',
+                '        fi',
+                '        ;;',
+                '    esac',
+                '  fi',
                 '} >> "$log" 2>&1',
                 'exit 0',
             ].join('\n') + '\n';