@planu/cli 5.3.67 → 5.3.69

package/dist/tools/triage-request.d.ts

@@ -15,6 +15,6 @@ export declare const TriageRequestInputSchema: z.ZodObject<{
     projectId: z.ZodOptional<z.ZodString>;
     specId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
-export type TriageRequestInput = z.infer<typeof TriageRequestInputSchema>;
-export declare function handleTriageRequest(input: TriageRequestInput): Promise<ToolResult>;
+export type TriageRequestParsedInput = z.infer<typeof TriageRequestInputSchema>;
+export declare function handleTriageRequest(input: TriageRequestParsedInput): Promise<ToolResult>;
 //# sourceMappingURL=triage-request.d.ts.map

package/dist/tools/update-status/approval-gates.d.ts

@@ -1,13 +1,13 @@
 import type { FormatGateOutput } from '../../types/spec/inputs.js';
 import type { Spec } from '../../types/spec/core.js';
-export interface ComplianceGateResult {
+export interface ApprovalComplianceGateResult {
     skipped: boolean;
     score: number | null;
     issues: string[];
     blocked: boolean;
 }
 /** Run the optional compliance check for a transition into review. */
-export declare function checkComplianceGate(specId: string, projectId: string, projectPath: string | undefined): Promise<ComplianceGateResult>;
+export declare function checkComplianceGate(specId: string, projectId: string, projectPath: string | undefined): Promise<ApprovalComplianceGateResult>;
 /** Validate canonical spec format before approval, preserving audited bypass warnings. */
 export declare function checkApprovedFormatGate(spec: Spec, newStatus: string, forceApprove?: boolean | undefined): Promise<FormatGateOutput>;
 //# sourceMappingURL=approval-gates.d.ts.map

package/dist/tools/update-status/approval-gates.js

@@ -1,3 +1,4 @@
+// eslint-disable-next-line no-restricted-imports -- grandfathered layer violation, remediation SPEC-1661 SPEC-1662 SPEC-1663
 import { validateSpecFormat } from '../../core/spec-validator.js';
 import { getComplianceGateConfig } from '../../storage/compliance-gate-config-store.js';
 import { formatKeyValue } from '../output-formatter.js';

package/dist/tools/update-status/dod-gates.d.ts

@@ -118,7 +118,7 @@ export declare function checkImplementationReviewGate(specId: string, projectId:
  */
 export declare function checkDoneGates(spec: Spec, specId: string, projectId: string, projectPath: string | undefined, _force: boolean | undefined, _forceReason?: string, verifyReceipt?: DoneReceiptVerifier, implementationReviewDigest?: string): Promise<DoneGateResult>;
 export { checkQaGate } from './qa-gate.js';
-export { checkApprovedFormatGate, checkComplianceGate, type ComplianceGateResult, } from './approval-gates.js';
+export { checkApprovedFormatGate, checkComplianceGate, type ApprovalComplianceGateResult, } from './approval-gates.js';
 /**
  * Run the validate gate wrapped in withEscalation for bounded retries.
  *

package/dist/tools/update-status/done-receipt-verifier.d.ts

@@ -1,4 +1,4 @@
-import { type DurableJobRecord } from '../../storage/runtime-db.js';
+import type { DurableJobRecord } from '../../types/durable-job.js';
 import { type ValidationFreshnessLease } from '../../engine/validation/validation-freshness.js';
 export { doneReceiptBindingsDifferOnlyInEvidence } from '../../engine/validation/durable-validation.js';
 export type DoneReceiptVerifier = (identity: {

package/dist/tools/update-status/evidence-gate.js

@@ -51,7 +51,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
     return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
 });
 import { readFile } from 'node:fs/promises';
-import { isAbsolute, join } from 'node:path';
+import { resolvePortableSpecPath } from '../../storage/project-identity.js';
 import { extractCriteria } from '../../engine/validator/extractors.js';
 import { readEvidenceArtifacts } from '../../engine/evidence-gates/artifact-reader.js';
 import { checkLifecycleEvidenceGate } from '../../engine/evidence-gates/lifecycle-gate.js';
@@ -290,9 +290,7 @@ async function currentBindingsAreFresh(identity, currentBindings) {
         return false;
     }
     try {
-        const specPath = isAbsolute(identity.specPath)
-            ? identity.specPath
-            : join(identity.projectPath, identity.specPath);
+        const specPath = await resolvePortableSpecPath(identity.specId, identity.specPath, identity.projectPath);
         const observed = await computeDurableValidationBindings({
             canonicalProjectId: identity.projectId,
             specId: identity.specId,
@@ -311,8 +309,10 @@ async function currentBindingsAreFresh(identity, currentBindings) {
     }
 }
 async function extractLifecycleGateCriteriaAndBody(spec, projectPath) {
-    const specPath = isAbsolute(spec.specPath) || !projectPath ? spec.specPath : join(projectPath, spec.specPath);
     try {
+        const specPath = projectPath
+            ? await resolvePortableSpecPath(spec.id, spec.specPath, projectPath)
+            : spec.specPath;
         const raw = await readFile(specPath, 'utf-8');
         const criteria = extractAcceptanceCriteriaTexts(raw);
         if (criteria.length > 0) {

package/dist/tools/update-status/file-sync.js

@@ -3,12 +3,12 @@ import { metricsStore } from '../../storage/index.js';
 import { addLesson, getLessons } from '../../storage/lessons-store.js';
 import { dispatchFeedbackEvent } from '../learn.js';
 import { autoReconcileOnDone } from '../update-status-reconcile.js';
-import { lstat, readFile, realpath } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { parseFrontmatter } from '../../engine/frontmatter-parser.js';
 import { computeFrontmatterSha } from '../../engine/frontmatter-sha/index.js';
 import { appendTransitionEvent } from '../../storage/transition-log.js';
 import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
-import { isAbsolute, normalize, relative, resolve, sep } from 'node:path';
+import { resolvePortableSpecPath, PortablePathError } from '../../storage/project-identity.js';
 import { redactFailureMessage, reportClassifiedDegradation, } from '../../errors/classified-degradation.js';
 export async function recordDoneMetrics(projectId, specId, spec, actuals, projectPath) {
     if (actuals.devHours + actuals.reviewHours === 0) {
@@ -97,46 +97,18 @@ async function resolveSpecPathForTransition(spec, projectPath) {
     if (!projectPath) {
         return spec.specPath;
     }
-    const normalizedPath = normalize(spec.specPath);
-    const segments = normalizedPath.split(sep).filter(Boolean);
-    const planuIndex = segments.lastIndexOf('planu');
-    const specDirectory = segments[planuIndex + 2];
-    const isPortableContract = planuIndex >= 0 &&
-        segments[planuIndex + 1] === 'specs' &&
-        segments[planuIndex + 3] === 'spec.md' &&
-        planuIndex + 4 === segments.length &&
-        specDirectory !== undefined &&
-        (specDirectory === spec.id || specDirectory.startsWith(`${spec.id}-`));
-    if (!isPortableContract) {
-        throw new Error('SPEC_PATH_RELOCALIZATION_FAILED: specPath is not a portable spec contract');
-    }
-    const selectedRoot = resolve(projectPath);
-    const candidate = resolve(selectedRoot, 'planu', 'specs', specDirectory, 'spec.md');
-    const relativeCandidate = relative(selectedRoot, candidate);
-    if (relativeCandidate.startsWith(`..${sep}`) ||
-        relativeCandidate === '..' ||
-        isAbsolute(relativeCandidate)) {
-        throw new Error('SPEC_PATH_RELOCALIZATION_FAILED: specPath escapes the selected root');
+    try {
+        return await resolvePortableSpecPath(spec.id, spec.specPath, projectPath);
     }
-    const rootRealpath = await realpath(selectedRoot);
-    const [candidateRealpath, candidateStat] = await Promise.all([
-        realpath(candidate),
-        lstat(candidate),
-    ]).catch((err) => {
-        if (err instanceof Error && err.code === 'ENOENT') {
-            throw specArtifactAbsentError();
+    catch (error) {
+        if (error instanceof PortablePathError) {
+            if (error.code === 'NOT_FOUND') {
+                throw specArtifactAbsentError();
+            }
+            throw new Error(`SPEC_PATH_RELOCALIZATION_FAILED: ${error.message}`, { cause: error });
         }
-        throw err;
-    });
-    const realRelative = relative(rootRealpath, candidateRealpath);
-    if (candidateStat.isSymbolicLink() ||
-        !candidateStat.isFile() ||
-        realRelative.startsWith(`..${sep}`) ||
-        realRelative === '..' ||
-        isAbsolute(realRelative)) {
-        throw new Error('SPEC_PATH_RELOCALIZATION_FAILED: specPath is not a contained regular file');
+        throw error;
     }
-    return candidateRealpath;
 }
 function bodyWithoutFrontmatter(content) {
     return parseFrontmatter(content).body;

package/dist/tools/update-status/index.js

@@ -932,7 +932,7 @@ export async function handleUpdateStatus(params, server) {
                         return ambiguityError;
                     }
                     // SPEC-769: Readiness gate — block 'approved' if spec has 0 criteria or score < 70
-                    const readinessGate = await checkReadinessGate(spec, approvalGateStatus, params.forceApprove);
+                    const readinessGate = await checkReadinessGate(spec, approvalGateStatus, params.forceApprove, transitionProjectPath);
                     if (readinessGate.blockResult) {
                         return readinessGate.blockResult;
                     }

package/dist/tools/update-status/side-effects.js

@@ -1,9 +1,14 @@
 import { specStore } from '../../storage/index.js';
 import { runCascade } from '../../engine/cascade-hooks/runner.js';
+import { setDispatchHookEventHandler } from '../../engine/cascade-hooks/hooks/dispatch-hook-event.hook.js';
 import { appendAutopilotLogEntry } from '../../storage/autopilot-log-store.js';
 import { redactFailureMessage, reportClassifiedDegradation, } from '../../errors/classified-degradation.js';
 import { getRuntimePolicy } from '../../engine/runtime-policy.js';
 import { createExecutionScope } from '../../engine/execution/context.js';
+import { dispatchHookEvent } from '../manage-hooks.js';
+// Wire the tools-layer hook dispatcher into the engine's cascade hook
+// (see engine/cascade-hooks/hooks/dispatch-hook-event.hook.ts — engine must not import tools/ directly).
+setDispatchHookEventHandler(dispatchHookEvent);
 const queuedTransitions = new Map();
 const CASCADE_ISOLATED_SCOPE_MS = 30_000;
 const pendingPostCommitWork = new Set();

package/dist/tools/update-status/transition-guard.d.ts

@@ -73,7 +73,7 @@ export declare function checkSpecArtifactCommittedGate(spec: Spec, newStatus: Sp
  * - non-English prose → hard block
  * - score >= 70 → proceed, no warnings
  */
-export declare function checkReadinessGate(spec: Spec, newStatus: SpecStatus, forceApprove: boolean | undefined): Promise<ReadinessGateOutput>;
+export declare function checkReadinessGate(spec: Spec, newStatus: SpecStatus, forceApprove: boolean | undefined, projectPath?: string): Promise<ReadinessGateOutput>;
 /**
  * SPEC-964: Challenge gate — block 'review' if challenge_spec was never run
  * or does not contain enough explicit resolution evidence.

package/dist/tools/update-status/transition-guard.js

@@ -1,6 +1,7 @@
 // tools/update-status/transition-guard.ts — Valid state transitions and DoR gate
 import { readFile } from 'node:fs/promises';
 import { isAbsolute, join } from 'node:path';
+import { toPortableSpecPath, resolveVerifiedSpecPath, PortablePathError, } from '../../storage/project-identity.js';
 import { ti } from '../../i18n/index.js';
 import { validateDoR } from '../../engine/dor-dod.js';
 import { dispatchFeedbackEvent } from '../learn.js';
@@ -237,9 +238,30 @@ export async function checkSpecArtifactCommittedGate(spec, newStatus, projectPat
     if (newStatus !== 'implementing' || !projectPath || !spec.specPath) {
         return null;
     }
-    const absoluteSpecPath = isAbsolute(spec.specPath)
-        ? spec.specPath
-        : join(projectPath, spec.specPath);
+    let absoluteSpecPath;
+    try {
+        absoluteSpecPath = join(projectPath, toPortableSpecPath(spec.id, spec.specPath));
+    }
+    catch (error) {
+        if (!(error instanceof PortablePathError)) {
+            throw error;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: formatKeyValue({
+                        error: 'SPEC_PATH_UNRESOLVABLE',
+                        message: `spec.md for ${spec.id} could not be resolved under the canonical project root (${error.code}).`,
+                        specId: spec.id,
+                        fixHint: 'Run reconcile_spec to re-link this spec to its file, then retry update_status.',
+                    }),
+                },
+            ],
+            isError: true,
+            structuredContent: { error: 'SPEC_PATH_UNRESOLVABLE', code: error.code, specId: spec.id },
+        };
+    }
     try {
         const { git } = await import('../git/git-helpers.js');
         const { stdout } = await git(projectPath, ['status', '--porcelain', '--', absoluteSpecPath]);
@@ -286,13 +308,18 @@ export async function checkSpecArtifactCommittedGate(spec, newStatus, projectPat
  * - non-English prose → hard block
  * - score >= 70 → proceed, no warnings
  */
-export async function checkReadinessGate(spec, newStatus, forceApprove) {
+export async function checkReadinessGate(spec, newStatus, forceApprove, projectPath) {
     if ((newStatus !== 'review' && newStatus !== 'approved') || !spec.specPath) {
         return { blockResult: null, qualityWarnings: [] };
     }
     let body;
+    let resolvedPath;
     try {
-        body = await readFile(spec.specPath, 'utf-8');
+        resolvedPath =
+            !isAbsolute(spec.specPath) && projectPath
+                ? await resolveVerifiedSpecPath(spec.id, spec.specPath, projectPath)
+                : spec.specPath;
+        body = await readFile(resolvedPath, 'utf-8');
     }
     catch (error) {
         /* reliability-optional: READINESS_SPEC_UNREADABLE — transition fails closed below */
@@ -301,10 +328,12 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
         // situation — surface an actionable message instead of the raw fs error
         // ("ENOENT: no such file or directory, open '<path>'") that update_status
         // was previously appending "Transition blocked..." to verbatim.
-        const isMissingFile = typeof error === 'object' &&
+        const isMissingFile = (typeof error === 'object' &&
             error !== null &&
             'code' in error &&
-            error.code === 'ENOENT';
+            error.code === 'ENOENT') ||
+            (error instanceof PortablePathError &&
+                (error.code === 'NOT_FOUND' || error.code === 'ROOT_NOT_FOUND'));
         return readinessUnavailable('READINESS_SPEC_UNREADABLE', isMissingFile
             ? `spec.md is missing at ${spec.specPath}. Recreate the spec via create_spec or restore spec.md from git/backup before retrying this transition.`
             : error instanceof Error
@@ -397,9 +426,12 @@ export async function checkReadinessGate(spec, newStatus, forceApprove) {
             qualityWarnings: structuralInterpolationWarnings,
         };
     }
+    const specWithResolvedPath = resolvedPath === spec.specPath
+        ? spec
+        : { ...spec, specPath: resolvedPath, technicalPath: resolvedPath };
     let readiness;
     try {
-        readiness = await checkSpecReadiness(spec, 'strict');
+        readiness = await checkSpecReadiness(specWithResolvedPath, 'strict');
     }
     catch (error) {
         /* reliability-optional: READINESS_EVALUATION_FAILED — transition fails closed below */

package/dist/tools/update-status-actions.js

@@ -78,12 +78,18 @@ export async function runImplementingSideEffects(projectId, specId, transitionPr
     try {
         const spec = foundSpec ?? (await specStore.getSpec(projectId, specId));
         const results = await Promise.allSettled([
-            // SPEC-633: Write session state when spec moves to implementing
+            // SPEC-633: Write session state when spec moves to implementing, then refresh
+            // the paired session artifacts from the resulting store state.
             (async () => {
-                const { writeSpecSessionState } = await import('../engine/session-state/writer.js');
-                await writeSpecSessionState(projectPath, specId, spec?.title ?? specId, 'moved to implementing').catch(() => {
+                try {
+                    const { writeSpecSessionState } = await import('../engine/session-state/writer.js');
+                    await writeSpecSessionState(projectPath, specId, spec?.title ?? specId, 'moved to implementing');
+                    const { refreshSessionArtifacts } = await import('../engine/session-state/session-artifact-refresher.js');
+                    await refreshSessionArtifacts(projectPath, projectId);
+                }
+                catch {
                     /* best-effort */
-                });
+                }
             })(),
             // SPEC-635: Regenerate context.md
             (async () => {
@@ -92,19 +98,6 @@ export async function runImplementingSideEffects(projectId, specId, transitionPr
                     /* best-effort */
                 });
             })(),
-            // SPEC-656: Recalculate epicProgress when spec moves to implementing
-            (async () => {
-                try {
-                    const { updateEpicProgressInSession } = await import('../engine/session-state/writer.js');
-                    const allSpecs = await specStore.listSpecs(projectId);
-                    await updateEpicProgressInSession(projectPath, allSpecs).catch(() => {
-                        /* best-effort */
-                    });
-                }
-                catch {
-                    /* best-effort */
-                }
-            })(),
             // recommend_model — suggest haiku/sonnet/opus based on spec complexity
             (async () => {
                 try {
@@ -166,13 +159,6 @@ export async function runDoneActions(projectId, specId, gitBranch, options = {})
             try {
                 const { resolveProjectPath, git: gitCmd } = await import('./git/git-helpers.js');
                 const projectPath = suppliedProjectPath(options.projectPath) ?? (await resolveProjectPath(projectId));
-                if (process.env.PLANU_ENABLE_AUTOCOMMIT === 'true') {
-                    await gitCmd(projectPath, ['add', 'planu/']);
-                    const { planuAutoCommit } = await import('../engine/git/planu-autocommit.js');
-                    void planuAutoCommit({ projectPath, specId, reason: 'mark-done' }).catch((err) => {
-                        console.error('[update-status] planuAutoCommit failed:', err instanceof Error ? err.message : String(err));
-                    });
-                }
                 const { stdout } = await gitCmd(projectPath, ['status', '--porcelain']);
                 const nonPlanuLines = stdout
                     .trim()
@@ -243,15 +229,6 @@ export async function runDoneSideEffects(projectId, specId, gitBranch, transitio
             const { cleanupSpecOnDone } = await import('./git/cleanup-ops.js');
             return withAudit(projectPath, 'update_status(done)', 'cleanupSpecOnDone', () => cleanupSpecOnDone(projectPath, specId, gitBranch));
         })(),
-        (async () => {
-            const { removeSpecFromSession } = await import('../engine/session-state/writer.js');
-            await removeSpecFromSession(projectPath, specId);
-        })(),
-        (async () => {
-            const { updateEpicProgressInSession } = await import('../engine/session-state/writer.js');
-            const allSpecs = await specStore.listSpecs(projectId);
-            await updateEpicProgressInSession(projectPath, allSpecs);
-        })(),
         (async () => {
             const { generateContextMd } = await import('../engine/context-md-generator.js');
             await generateContextMd(projectPath, projectId);
@@ -266,26 +243,37 @@ export async function runDoneSideEffects(projectId, specId, gitBranch, transitio
             return runHousekeepingSweep({ projectPath });
         })(),
         (async () => {
-            if (hasPending(specId, 'generateSessionContext')) {
+            if (hasPending(specId, 'refreshSessionArtifacts')) {
                 return;
             }
-            markPending(specId, 'generateSessionContext');
+            markPending(specId, 'refreshSessionArtifacts');
             try {
-                const { generateSessionContext } = await import('../engine/session-context-generator.js');
-                await generateSessionContext(projectPath, projectId);
+                const { refreshSessionArtifacts } = await import('../engine/session-state/session-artifact-refresher.js');
+                await refreshSessionArtifacts(projectPath, projectId);
             }
             finally {
-                clearPending(specId, 'generateSessionContext');
+                clearPending(specId, 'refreshSessionArtifacts');
             }
         })(),
     ]);
+    if (process.env.PLANU_ENABLE_AUTOCOMMIT === 'true') {
+        try {
+            const { git: gitCmd } = await import('./git/git-helpers.js');
+            await gitCmd(projectPath, ['add', 'planu/']);
+            const { planuAutoCommit } = await import('../engine/git/planu-autocommit.js');
+            await planuAutoCommit({ projectPath, specId, reason: 'mark-done' });
+        }
+        catch (err) {
+            console.error('[update-status] planuAutoCommit failed:', err instanceof Error ? err.message : String(err));
+        }
+    }
     const failures = results.filter((result) => result.status === 'rejected');
     if (failures.length > 0) {
         throw new AggregateError(normalizeRejectedReasons(failures), `${String(failures.length)} done side effect(s) failed`);
     }
     const cleanup = results[0].status === 'fulfilled' ? results[0].value : null;
-    const planuCleanup = results[4].status === 'fulfilled' ? results[4].value : null;
-    const housekeeping = results[5].status === 'fulfilled' ? results[5].value : null;
+    const planuCleanup = results[2].status === 'fulfilled' ? results[2].value : null;
+    const housekeeping = results[3].status === 'fulfilled' ? results[3].value : null;
     return {
         cleanupProposals: cleanup?.proposals ?? [],
         housekeepingProposal: housekeeping ?? {

package/dist/tools/validate-graph-coverage.js

@@ -11,6 +11,9 @@ function graphCoverageGaps(slice) {
         .map((criterion) => criterion.label)
         .slice(0, 10);
 }
+function graphCoverageWarnings(slice) {
+    return slice.oversizedSources.map((record) => `oversized source: ${record.path} (${record.kind}, ${record.action})`);
+}
 export async function buildGraphCoverageReport(args) {
     let graphSlice;
     try {
@@ -21,7 +24,13 @@ export async function buildGraphCoverageReport(args) {
         graphSlice = null;
     }
     if (graphSlice === null) {
-        return { availability: 'unavailable', gaps: [], compactNodes: 0, compactEdges: 0 };
+        return {
+            availability: 'unavailable',
+            gaps: [],
+            compactNodes: 0,
+            compactEdges: 0,
+            warnings: [],
+        };
     }
     return {
         availability: 'available',
@@ -29,14 +38,17 @@ export async function buildGraphCoverageReport(args) {
         gaps: graphCoverageGaps(graphSlice),
         compactNodes: graphSlice.nodes.length,
         compactEdges: graphSlice.edges.length,
+        warnings: graphCoverageWarnings(graphSlice),
     };
 }
 export function formatGraphCoverageText(report) {
     if (report.availability === 'unavailable') {
         return '\nGRAPH     unavailable (project graph unreadable)';
     }
-    return report.gaps.length > 0
+    const gapLine = report.gaps.length > 0
         ? `\nGRAPH     ${String(report.gaps.length)} graph-backed coverage gap(s)`
         : '';
+    const warningLines = report.warnings.map((warning) => `\nGRAPH     ${warning}`).join('');
+    return gapLine + warningLines;
 }
 //# sourceMappingURL=validate-graph-coverage.js.map

package/dist/tools/validate.js

@@ -867,6 +867,8 @@ function buildValidateStructuredContent(args) {
             availability: args.graphCoverage.availability,
             gapsCount: args.graphCoverage.gaps.length,
             gapsTop5: args.graphCoverage.gaps.slice(0, 5),
+            warningsCount: args.graphCoverage.warnings.length,
+            warningsTop5: args.graphCoverage.warnings.slice(0, 5),
             freshness: args.graphCoverage.freshness,
         },
         suggestionsTop5: args.suggestions.slice(0, 5),

package/dist/transports/middleware/types.d.ts

@@ -11,9 +11,9 @@ export interface ToolContext {
 /**
  * A tool handler function signature.
  */
-export type ToolHandler = (input: Record<string, unknown>, ctx: ToolContext) => Promise<ToolResult>;
+export type MiddlewareToolHandler = (input: Record<string, unknown>, ctx: ToolContext) => Promise<ToolResult>;
 /**
- * A middleware is a higher-order function that wraps a ToolHandler.
+ * A middleware is a higher-order function that wraps a MiddlewareToolHandler.
  */
-export type Middleware = (handler: ToolHandler) => ToolHandler;
+export type Middleware = (handler: MiddlewareToolHandler) => MiddlewareToolHandler;
 //# sourceMappingURL=types.d.ts.map

package/dist/types/atomic-upgrade.d.ts

@@ -1,5 +1,5 @@
 import type { SpawnSyncReturns } from 'node:child_process';
-import type { InstallationManifest, InstallationRecord } from '../cli/commands/install.js';
+import type { InstallationManifest, InstallationRecord } from './installation.js';
 export type UpgradePhase = 'after-runtime-verification' | 'before-adapter-switch' | 'after-adapter-switch' | 'before-manifest-switch' | 'after-manifest-switch' | 'after-trust-switch';
 export type UpgradeJournalState = 'prepared' | 'switching' | 'trust-switched' | 'committed';
 export interface UpgradeJournal {

package/dist/types/cascade-hooks.d.ts

@@ -1,5 +1,8 @@
 import type { Spec } from './spec/core.js';
 import type { SpecStatus } from './common/primitives.js';
+import type { HookEventPayload } from './hooks.js';
+/** Port through which the dispatch-hook-event hook reaches the tools-layer hook dispatcher. */
+export type DispatchHookEventFn = (projectId: string, payload: HookEventPayload) => Promise<void>;
 export interface CascadeContext {
     specId: string;
     spec: Spec;

package/dist/types/cross-repo-search.d.ts

@@ -13,6 +13,8 @@ export interface RegisteredProject {
     specCount: number;
     /** ISO timestamp of the last spec scan, if any */
     lastScanAt?: string;
+    /** Logical project identity from planu/project.json, when the checkout has one */
+    logicalProjectId?: string;
 }
 /**
  * Global registry persisted at data/global/registered-projects.json.

package/dist/types/dashboard.d.ts

@@ -1,4 +1,5 @@
-import type { Difficulty, RiskLevel, SpecStatus } from './common/index.js';
+import type { Difficulty, RiskLevel, SpecStatus, ToolResult } from './common/index.js';
+import type { UpdateStatusInput } from './spec/inputs.js';
 /** State of the dashboard HTTP server (singleton in memory) */
 export interface DashboardServerState {
     port: number;
@@ -69,6 +70,8 @@ export interface SpecStatusUpdateResult {
     newStatus: string;
     error?: string;
 }
+/** Port through which the dashboard status route reaches the tools-layer status gate. */
+export type UpdateStatusHandler = (input: UpdateStatusInput) => Promise<ToolResult>;
 /** Project health score with weighted components */
 export interface ProjectHealthScore {
     overall: number;

package/dist/types/durable-job.d.ts

@@ -35,4 +35,24 @@ export interface ValidateDurableJobPayload {
     readonly freshnessLease?: ValidationFreshnessLease;
     readonly specPath: string;
 }
+export declare const DURABLE_JOB_STATES: readonly ['accepted', 'running', 'checkpointed', 'cancelled', 'failed', 'dead-letter', 'completed'];
+export type DurableJobState = (typeof DURABLE_JOB_STATES)[number];
+export interface DurableJobRecord {
+    readonly id: string;
+    readonly projectId: string;
+    readonly workspaceId: string;
+    readonly state: DurableJobState;
+    readonly payload: unknown;
+    readonly checkpoint?: unknown;
+    readonly result?: unknown;
+    readonly error?: string;
+    readonly attempts: number;
+    readonly maxAttempts: number;
+    readonly cancelRequested: boolean;
+    readonly leaseOwner?: string;
+    readonly leaseExpiresAt?: string;
+    readonly fencingToken: number;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
 //# sourceMappingURL=durable-job.d.ts.map

package/dist/types/durable-job.js

@@ -1,2 +1,10 @@
-export {};
+export const DURABLE_JOB_STATES = [
+    'accepted',
+    'running',
+    'checkpointed',
+    'cancelled',
+    'failed',
+    'dead-letter',
+    'completed',
+];
 //# sourceMappingURL=durable-job.js.map

package/dist/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from './agent-roles.js';
+export * from './installation.js';
 export * from './cost-ledger.js';
 export * from './autopilot-summary.js';
 export * from './common/index.js';
@@ -264,6 +265,7 @@ export * from './agent-memory.js';
 export * from './agent-spawner.js';
 export * from './qa-gate.js';
 export * from './validation-evidence.js';
+export * from './spec-dependency-graph.js';
 export * from './project-drift.js';
 export * from './technical-enrichment.js';
 export * from './agent-team.js';

package/dist/types/index.js

@@ -1,5 +1,6 @@
 // Planu — SDD MCP Server Types (barrel re-export)
 export * from './agent-roles.js';
+export * from './installation.js';
 export * from './cost-ledger.js';
 export * from './autopilot-summary.js';
 export * from './common/index.js';
@@ -261,6 +262,7 @@ export * from './agent-memory.js';
 export * from './agent-spawner.js';
 export * from './qa-gate.js';
 export * from './validation-evidence.js';
+export * from './spec-dependency-graph.js';
 export * from './project-drift.js';
 export * from './technical-enrichment.js';
 export * from './agent-team.js';

package/dist/types/installation.d.ts

@@ -0,0 +1,16 @@
+export interface InstallationRecord {
+    host: string;
+    configPath: string;
+    format: 'standard' | 'zed';
+    scope: 'user' | 'project';
+    package: string;
+    version: string;
+    offline: boolean;
+    installedAt: string;
+}
+export interface InstallationManifest {
+    schemaVersion: 1;
+    updatedAt: string;
+    installations: InstallationRecord[];
+}
+//# sourceMappingURL=installation.d.ts.map

package/dist/types/installation.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=installation.js.map