@planu/cli 4.13.0 → 5.0.0

package/dist/tools/init-project/migration-runner.js

@@ -2,6 +2,48 @@
 import { specStore, knowledgeStore } from '../../storage/index.js';
 import { projectDataDir, writeJson } from '../../storage/base-store.js';
 import { filterLegacySpecs, migrateSpecs, filterUnprefixedSpecs, migrateSpecFolderNames, discoverAndFlattenSpecs, reconcileSpecPaths, migrateAllSpecsToLean, } from '../../engine/spec-migrator.js';
+import { reconcilePortableSpecIndex } from './portable-index-reconciler.js';
+import { createHash } from 'node:crypto';
+import { lstat, readFile, readdir, readlink } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+async function snapshotPlanuTree(projectPath) {
+    const root = join(projectPath, 'planu');
+    const snapshot = new Map();
+    const pending = [root];
+    try {
+        while (pending.length > 0) {
+            const directory = pending.pop();
+            if (directory === undefined) {
+                continue;
+            }
+            const entries = await readdir(directory, { withFileTypes: true }).catch(() => []);
+            for (const entry of entries) {
+                const absolute = join(directory, entry.name);
+                const path = relative(projectPath, absolute).replaceAll('\\', '/');
+                if (entry.isDirectory()) {
+                    pending.push(absolute);
+                }
+                else if (entry.isSymbolicLink()) {
+                    snapshot.set(path, `link:${await readlink(absolute)}`);
+                }
+                else if ((await lstat(absolute)).isFile()) {
+                    snapshot.set(path, createHash('sha256')
+                        .update(await readFile(absolute))
+                        .digest('hex'));
+                }
+            }
+        }
+    }
+    catch {
+        // Test doubles and unreadable files degrade reporting, never migration safety.
+    }
+    return snapshot;
+}
+function changedPaths(before, after) {
+    return [...new Set([...before.keys(), ...after.keys()])]
+        .filter((path) => before.get(path) !== after.get(path))
+        .sort();
+}
 function issueFromError(phase, severity, err) {
     return {
         phase,
@@ -19,7 +61,9 @@ function issuesFromMessages(phase, severity, messages) {
  * 3. Reconcile stale paths in specs.json
  * 4. Migrate spec folders without SPEC-XXX- prefix
  */
-export async function runSpecMigrations(projectPath, projectId, knowledge) {
+export async function runSpecMigrations(projectPath, projectId, knowledge, options = {}) {
+    const before = await snapshotPlanuTree(projectPath);
+    const authorizedUpdate = options.repositoryMigration === 'planu-spec-format-v1';
     // Auto-discover and flatten specs in subcategory folders (v0.30 → v0.40 migration)
     let discoveryResult = null;
     const criticalMigrationFailures = [];
@@ -31,6 +75,16 @@ export async function runSpecMigrations(projectPath, projectId, knowledge) {
     catch (err) {
         criticalMigrationFailures.push(issueFromError('discover-and-flatten-specs', 'critical', err));
     }
+    // Rebuild missing mutable index records from the portable Git contract.
+    // This is required after a storage-root migration or a clean-machine import.
+    let filesystemImportResult = null;
+    try {
+        filesystemImportResult = await reconcilePortableSpecIndex(projectPath, projectId);
+        criticalMigrationFailures.push(...issuesFromMessages('filesystem-spec-import', 'critical', filesystemImportResult.errors));
+    }
+    catch (err) {
+        criticalMigrationFailures.push(issueFromError('filesystem-spec-import', 'critical', err));
+    }
     // Auto-migrate legacy specs if detected (docs/sdd/specs/ → planu/specs/)
     let allSpecs = [];
     try {
@@ -41,7 +95,14 @@ export async function runSpecMigrations(projectPath, projectId, knowledge) {
     }
     const legacySpecs = filterLegacySpecs(allSpecs);
     let migrationResult = null;
-    if (legacySpecs.length > 0) {
+    if (legacySpecs.length > 0 && authorizedUpdate) {
+        criticalMigrationFailures.push({
+            phase: 'legacy-spec-migration',
+            severity: 'critical',
+            message: 'planu-spec-format-v1 is confined to planu/ and cannot migrate legacy docs/sdd paths.',
+        });
+    }
+    else if (legacySpecs.length > 0) {
         try {
             migrationResult = await migrateSpecs(projectPath, legacySpecs, {
                 listSpecs: specStore.listSpecs,
@@ -110,6 +171,7 @@ export async function runSpecMigrations(projectPath, projectId, knowledge) {
     catch (err) {
         criticalMigrationFailures.push(issueFromError('strict-planu-cleanup', 'critical', err));
     }
+    const repositoryFilesChanged = changedPaths(before, await snapshotPlanuTree(projectPath));
     let migrationReportPath = null;
     try {
         const reportPath = `${projectDataDir(projectId)}/reports/init-migrations/latest.json`;
@@ -118,10 +180,12 @@ export async function runSpecMigrations(projectPath, projectId, knowledge) {
             projectId,
             generatedAt: new Date().toISOString(),
             discoveryResult,
+            filesystemImportResult,
             migrationResult,
             folderMigrationResult,
             criticalMigrationFailures,
             nonCriticalWarnings,
+            changedPaths: repositoryFilesChanged,
         });
         migrationReportPath = reportPath;
     }
@@ -130,11 +194,13 @@ export async function runSpecMigrations(projectPath, projectId, knowledge) {
     }
     return {
         discoveryResult,
+        filesystemImportResult,
         migrationResult,
         folderMigrationResult,
         criticalMigrationFailures,
         nonCriticalWarnings,
         migrationReportPath,
+        changedPaths: repositoryFilesChanged,
     };
 }
 /** Return all specs for the project (needed by caller for health check refs). */

package/dist/tools/init-project/per-client-files-writer.js

@@ -18,9 +18,16 @@ alwaysApply: true
 \`\`\`
 facilitate("what to build") → create_spec → challenge_spec → check_readiness
 → update_status(review) → approve → update_status(approved) → implement
-→ validate → update_status(done)
+→ validate (ack) → watch_job (completed) → inspect job.result → update_status(done)
 \`\`\`
 
+## Durable Validation Gate
+
+1. Call \`validate\` and capture \`operationId\`, \`projectId\`, \`workspaceId\`, and \`cursor\`
+2. Call \`watch_job\` with the latest cursor until terminal
+3. Require \`completed\` and inspect \`job.result.structuredContent\`; stop on \`failed\`, \`dead-letter\`, or \`cancelled\`
+4. Mark done only when the completed result reports \`ready: true\`, \`status: "passing"\`, and passing quality gates
+
 ## Session Start
 
 1. Call \`planu_status\` to see active specs
@@ -47,7 +54,7 @@ Planu enforces Spec Driven Development — spec first, then implement, then vali
 
 - Starting a new feature: use \`facilitate()\` or \`create_spec()\`
 - Resuming work: use \`planu_status\` to see what's in progress
-- Finishing work: use \`validate()\` then \`update_status(done)\`
+- Finishing work: submit \`validate()\`, await \`watch_job()\`, inspect \`job.result.structuredContent\`, then use \`update_status(done)\`
 
 ## Mandatory Workflow
 
@@ -56,13 +63,16 @@ Planu enforces Spec Driven Development — spec first, then implement, then vali
 3. \`check_readiness(specId)\` — verify criteria are complete
 4. \`update_status(specId, "approved")\` — lock the spec
 5. Implement the code
-6. \`validate(specId)\` — verify code matches spec
-7. \`update_status(specId, "done")\` — mark complete
+6. \`validate(specId)\` — submit validation and capture the durable job acknowledgement
+7. \`watch_job(operationId, projectId, workspaceId, cursor)\` — repeat until terminal
+8. Require \`completed\` and inspect \`job.result.structuredContent\`
+9. \`update_status(specId, "done")\` — mark complete only after a completed passing result
 
 ## Rules
 
 - NEVER write production code before spec is \`approved\`
 - NEVER skip \`validate\` after implementation
+- NEVER treat the \`validate\` acknowledgement as validation success
 - Specs stay \`spec.md\`-only. Do not recreate standalone \`technical.md\` or \`progress.md\`.
 `;
 const CODEX_NATIVE_SKILL_CONTENT = `# planu-native — Planu Lightweight Native Surface

package/dist/tools/init-project/portable-index-reconciler.d.ts

@@ -0,0 +1,4 @@
+import type { FilesystemImportDeps, PortableIndexReconciliationResult } from '../../types/index.js';
+/** Rebuild the mutable external index from the repository-owned portable contracts. */
+export declare function reconcilePortableSpecIndex(projectPath: string, projectId: string, deps?: FilesystemImportDeps): Promise<PortableIndexReconciliationResult>;
+//# sourceMappingURL=portable-index-reconciler.d.ts.map

package/dist/tools/init-project/portable-index-reconciler.js

@@ -0,0 +1,14 @@
+import { specStore } from '../../storage/index.js';
+import { importFilesystemSpecs } from '../../engine/spec-migrator/filesystem-import.js';
+/** Rebuild the mutable external index from the repository-owned portable contracts. */
+export async function reconcilePortableSpecIndex(projectPath, projectId, deps = {
+    listSpecs: specStore.listSpecs,
+    createSpec: specStore.createSpec,
+    getSpecFresh: specStore.getSpecFresh,
+}) {
+    const result = await importFilesystemSpecs(projectPath, deps, projectId, {
+        strictPortableContract: true,
+    });
+    return { ...result, repositoryFilesChanged: [] };
+}
+//# sourceMappingURL=portable-index-reconciler.js.map

package/dist/tools/init-project/result-builder.js

@@ -193,9 +193,8 @@ export function buildInitProjectResult(input) {
     const framework = result.framework ?? 'no framework detected';
     const action = isUpdate ? 'updated' : 'initialized';
     const telemetryNote = input.telemetryOptInPrompt
-        ? `\n\n---\n💡 **Help improve Planu** — run \`configure_telemetry\` with action=enable to share anonymous usage stats (no paths, no emails, no personal data). You can opt out anytime.`
+        ? `\n\n---\n💡 **Help improve Planu** — run \`configure_telemetry\` with action=enable, then set a valid \`PLANU_TELEMETRY_ENDPOINT\` and secret \`PLANU_TELEMETRY_TOKEN\` to share anonymous usage stats (no paths, no emails, no personal data). You can opt out anytime.`
         : '';
-    const trialNote = '';
     const tokenTip = `\n\n💡 Token tip: Add CLAUDE_CODE_SUBAGENT_MODEL=haiku to your .env — makes all read-only subagents ` +
         `(search, grep, file reads) use Haiku instead of your session model (4–18x cheaper for those tasks).`;
     const narrative = ti('tools.init_project.success', { projectPath: result.projectPath }) +
@@ -206,7 +205,6 @@ export function buildInitProjectResult(input) {
                 `See migrationReportPath in structuredContent${input.migrationReportPath ? ` (${input.migrationReportPath})` : ''}.`
             : '') +
         telemetryNote +
-        trialNote +
         tokenTip;
     // SPEC-491: Build interactiveQuestions for decisions that require user input
     const interactiveQuestions = [];

package/dist/tools/init-project/rules-generator.js

@@ -18,7 +18,14 @@ Auto-generated by \`init_project\`. Do not edit manually.
 | implementing | work in progress |
 | done | implemented + validated |
 
-Flow: \`facilitate → create_spec → challenge_spec → check_readiness → approve → implement → validate → done\`
+Flow: \`facilitate → create_spec → challenge_spec → check_readiness → approve → implement → validate (ack) → watch_job (completed) → inspect job.result → done\`
+
+## Durable Validation Gate
+
+1. Call \`validate\` and capture \`operationId\`, \`projectId\`, \`workspaceId\`, and \`cursor\` from the acknowledgement.
+2. Call \`watch_job\` with those identifiers and the latest cursor. Repeat while state is non-terminal.
+3. Require state \`completed\`, then inspect \`job.result.structuredContent\`. Stop and report \`failed\`, \`dead-letter\`, or \`cancelled\`.
+4. Call \`update_status(done)\` only after the completed result reports \`ready: true\`, \`status: "passing"\`, and passing quality gates.
 
 ## Evidence Gates
 
@@ -45,7 +52,7 @@ Any new feature, bug fix, refactor, integration, or task > 5 min.
 ## Session End
 
 - \`session_checkpoint\` — persist context for the next session
-- \`update_status(done)\` — if work is complete
+- \`update_status(done)\` — only after a completed passing validation job
 
 ## Quick Reference
 
@@ -63,6 +70,7 @@ Any new feature, bug fix, refactor, integration, or task > 5 min.
 
 - NEVER write code before spec is \`approved\`
 - NEVER skip \`validate\` after implementation
+- NEVER treat the initial \`validate\` acknowledgement as a passing result
 - NEVER create design docs outside \`planu/specs/\`
 - NEVER recreate legacy \`technical.md\`, \`progress.md\`, or \`HU.md\` files for new specs
 

package/dist/tools/init-project/scaffold-writer.d.ts

@@ -62,5 +62,5 @@ export interface ScaffoldWriteResult {
  * - ESLint/Prettier config
  * - Architecture rules
  */
-export declare function runScaffoldWriter(projectPath: string, projectId: string, knowledge: ProjectKnowledge, recommendedSkills: RecommendedSkill[], permissionsMode?: PermissionsMode, pluginsMode?: PluginInstallMode): Promise<ScaffoldWriteResult>;
+export declare function runScaffoldWriter(projectPath: string, projectId: string, knowledge: ProjectKnowledge, recommendedSkills: RecommendedSkill[], permissionsMode?: PermissionsMode, pluginsMode?: PluginInstallMode, installSkills?: boolean): Promise<ScaffoldWriteResult>;
 //# sourceMappingURL=scaffold-writer.d.ts.map

package/dist/tools/init-project/scaffold-writer.js

@@ -28,7 +28,7 @@ import { generateWorkflowSkills } from '../../engine/skill-generator/workflow-sk
  * - Architecture rules
  */
 // eslint-disable-next-line complexity
-export async function runScaffoldWriter(projectPath, projectId, knowledge, recommendedSkills, permissionsMode, pluginsMode) {
+export async function runScaffoldWriter(projectPath, projectId, knowledge, recommendedSkills, permissionsMode, pluginsMode, installSkills = true) {
     // Generate and write AI rules files
     const rulesResult = await runRulesWriter(projectPath, projectId, knowledge, recommendedSkills);
     // Git setup: hooks, flow detection, .gitignore (SPEC-001)
@@ -51,7 +51,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     let opencodeConfigScaffolded = false;
     try {
         const { installInitHostAssets } = await import('./host-assets-writer.js');
-        const hostAssets = await installInitHostAssets(projectPath, knowledge);
+        const hostAssets = await installInitHostAssets(projectPath, knowledge, installSkills);
         detectedAssetHosts = hostAssets.detectedHosts;
         hostRulesWritten = hostAssets.rulesInstalled.length;
         hostSkillsWritten = hostAssets.skillsInstalled.length;
@@ -152,7 +152,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-519: Write .claude/skills/compact.md if missing (best-effort)
     let compactSkillWritten = false;
-    if (shouldWriteClaudeAssets) {
+    if (shouldWriteClaudeAssets && installSkills) {
         try {
             compactSkillWritten = await generateCompactSkillIfMissing(projectPath);
         }
@@ -161,7 +161,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
         }
     }
     // SPEC-655: Write .claude/skills/find-skills.md if missing (best-effort, idempotent)
-    if (shouldWriteClaudeAssets) {
+    if (shouldWriteClaudeAssets && installSkills) {
         try {
             await generateFindSkillsIfMissing(projectPath);
         }
@@ -193,12 +193,14 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
         /* best-effort */
     }
     // SPEC-648: Generate per-client files (Cursor MDC, Codex skill) based on detected client
-    try {
-        const { generatePerClientFiles } = await import('./per-client-files-writer.js');
-        await generatePerClientFiles(projectPath);
-    }
-    catch {
-        /* best-effort */
+    if (installSkills) {
+        try {
+            const { generatePerClientFiles } = await import('./per-client-files-writer.js');
+            await generatePerClientFiles(projectPath);
+        }
+        catch {
+            /* best-effort */
+        }
     }
     // SPEC-530: Generate .claude/rules/conventions.md (best-effort, idempotent)
     let conventionsMdWritten = false;
@@ -225,7 +227,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-593: Write .claude/skills/planu-multi-teammate-review.md if missing (best-effort, idempotent)
     let multiTeammateReviewSkillWritten = false;
-    if (shouldWriteClaudeAssets) {
+    if (shouldWriteClaudeAssets && installSkills) {
         try {
             multiTeammateReviewSkillWritten =
                 await generateMultiTeammateReviewSkillIfMissing(projectPath);
@@ -253,7 +255,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     // (idempotent — skips files already up-to-date; best-effort, no-op elsewhere)
     let planuSubagentsScaffolded = false;
     let planuUxSkillsScaffolded = 0;
-    if (shouldWriteClaudeAssets) {
+    if (shouldWriteClaudeAssets && installSkills) {
         try {
             const { scaffoldPlanuSubagents, scaffoldPlanuSkills } = await import('../../hosts/claude-code/ux/index.js');
             const [subagentResult, skillResult] = await Promise.all([
@@ -302,11 +304,11 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
             /* best-effort — never fail init_project due to missing claude CLI */
         }
     }
-    // SPEC-680: Create .planu/skill-registry.json if it does not exist (idempotent, best-effort)
+    // SPEC-680: Create planu/skill-registry.json if it does not exist (idempotent, best-effort)
     try {
         const { readFile: readFileFn } = await import('node:fs/promises');
         const { join: joinFn } = await import('node:path');
-        const registryFilePath = joinFn(projectPath, '.planu', 'skill-registry.json');
+        const registryFilePath = joinFn(projectPath, 'planu', 'skill-registry.json');
         const existing = await readFileFn(registryFilePath, 'utf-8').catch(() => null);
         if (existing === null) {
             const now = new Date().toISOString();
@@ -324,7 +326,7 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
     }
     // SPEC-685: Generate all 22 workflow skill files (idempotent, best-effort)
     let workflowSkillsWritten = 0;
-    if (shouldWriteClaudeAssets) {
+    if (shouldWriteClaudeAssets && installSkills) {
         try {
             const skillResult = await generateWorkflowSkills(projectPath, knowledge);
             workflowSkillsWritten = skillResult.written.length;

package/dist/tools/jobs/handlers.d.ts

@@ -0,0 +1,15 @@
+import type { ToolResult } from '../../types/index.js';
+export interface JobToolIdentityInput {
+    operationId: string;
+    projectId: string;
+    workspaceId?: string;
+}
+export interface WatchJobToolInput extends JobToolIdentityInput {
+    afterCursor?: string;
+    timeoutMs?: number;
+}
+export declare function handleGetJob(input: JobToolIdentityInput): Promise<ToolResult>;
+export declare function handleWatchJob(input: WatchJobToolInput): Promise<ToolResult>;
+export declare function handleCancelJob(input: JobToolIdentityInput): Promise<ToolResult>;
+export declare function handleRestartJob(input: JobToolIdentityInput): Promise<ToolResult>;
+//# sourceMappingURL=handlers.d.ts.map

package/dist/tools/jobs/handlers.js

@@ -0,0 +1,158 @@
+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];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        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;
+        }
+        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;
+        }
+        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 { DurableJobRuntime, publicJobCursor } from '../../engine/execution/job-runtime.js';
+import { scheduleValidateJobExecution } from '../../engine/execution/validate-job-executor.js';
+import { isValidationReceiptPendingIntent, parseValidationReceiptPendingCheckpoint, } from '../../types/durable-validation.js';
+import { redactText } from '../../security/redactor.js';
+import { getRuntimePolicy } from '../../engine/runtime-policy.js';
+function result(payload) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(payload, null, 2) }],
+        structuredContent: payload,
+    };
+}
+function publicJob(runtime, job) {
+    const sanitized = runtime.observe(job);
+    if (job.state === 'completed') {
+        const { checkpoint: _checkpoint, error: _error, ...completed } = sanitized;
+        return completed;
+    }
+    if (!parseValidationReceiptPendingCheckpoint(job.checkpoint, checkpointLimits())) {
+        return sanitized;
+    }
+    const errorMessage = job.error === undefined ? RECEIPT_PENDING_MESSAGE : redactText(job.error);
+    return { ...sanitized, error: errorMessage, errorMessage };
+}
+const RECEIPT_PENDING_MESSAGE = '[Planu] VALIDATION_RECEIPT_PENDING action=restart_job';
+function checkpointLimits() {
+    const policy = getRuntimePolicy().validation;
+    return {
+        logMaxBytes: policy.receiptCheckpointLogMaxBytes,
+        resultMaxBytes: policy.receiptCheckpointResultMaxBytes,
+    };
+}
+export function handleGetJob(input) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const runtime = __addDisposableResource(env_1, new DurableJobRuntime(), false);
+        const job = runtime.get(input);
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+export async function handleWatchJob(input) {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const runtime = __addDisposableResource(env_2, new DurableJobRuntime(), false);
+        const job = await runtime.watch(input);
+        const observation = publicJob(runtime, job);
+        return result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) });
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+}
+export function handleCancelJob(input) {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const runtime = __addDisposableResource(env_3, new DurableJobRuntime(), false);
+        const job = runtime.cancel(input);
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
+}
+export function handleRestartJob(input) {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const runtime = __addDisposableResource(env_4, new DurableJobRuntime(), false);
+        const current = runtime.get(input);
+        const pending = parseValidationReceiptPendingCheckpoint(current.checkpoint, checkpointLimits());
+        if (!pending && isValidationReceiptPendingIntent(current.checkpoint)) {
+            throw new Error('[Planu] Invalid validation receipt checkpoint');
+        }
+        const job = pending ? runtime.restartReceiptPublication(input) : runtime.restart(input);
+        if (job.payload &&
+            typeof job.payload === 'object' &&
+            job.payload.kind === 'validate') {
+            scheduleValidateJobExecution(job.projectId, job.workspaceId);
+        }
+        const observation = publicJob(runtime, job);
+        return Promise.resolve(result({ schemaVersion: 1, job: observation, cursor: publicJobCursor(observation) }));
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        __disposeResources(env_4);
+    }
+}
+//# sourceMappingURL=handlers.js.map