@planu/cli 5.7.4 → 5.7.6

package/dist/tools/init-project/legacy-guidance-scanner.js

@@ -0,0 +1,176 @@
+// tools/init-project/legacy-guidance-scanner.ts — SPEC-1716
+// Neutralizes stale Planu-installed guidance that instructs agents to create
+// legacy standalone technical.md/progress.md files. Fail-closed by tiers:
+//   Tier 1 — delimited Planu block markers: rewrite only the block content.
+//   Tier 2 — composite fingerprint (allowlisted legacy filename + managed-by
+//            header): replace the whole file, backing up the prior content.
+//   Tier 3 — contradictory phrase alone: warning only, zero mutation.
+// Malformed markers (opening without closing) also fail closed: warning only.
+import { readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { atomicWriteFile } from '../../engine/safety/atomic-write-file.js';
+import { resolveContainedProjectFile } from '../../engine/safety/contained-project-file.js';
+import legacyGuidanceRegistry from '../../config/registries/legacy-guidance.json' with { type: 'json' };
+const REGISTRY = legacyGuidanceRegistry;
+async function resolveScanSurface(projectPath) {
+    const files = [...REGISTRY.hostSurfaceFiles];
+    for (const { dir, extension } of REGISTRY.hostSurfaceDirectories) {
+        let entries;
+        try {
+            entries = await readdir(join(projectPath, dir), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith(extension)) {
+                files.push(`${dir}/${entry.name}`);
+            }
+        }
+    }
+    return files;
+}
+function containsContradictoryPhrase(text) {
+    return REGISTRY.contradictoryPhrases.find((phrase) => text.includes(phrase));
+}
+const OPEN_MARKER_RE = /<!--\s*(planu[\w:-]*)\s*-->/g;
+/**
+ * Locate delimited `<!-- planu... --> ... <!-- /planu... -->` (or repeated-tag,
+ * as emitted by claude-md-generator.ts wrap()) blocks. Returns `null` when an
+ * opening marker has no matching close — the malformed-marker fail-closed case.
+ *
+ * Uses its own cursor (a fresh RegExp with `re.lastIndex` advanced past each
+ * close marker) instead of `matchAll` over the whole string — a repeated-tag
+ * close is itself a valid open-marker match, so scanning the string without
+ * skipping past it would misread that close as the next block's opener.
+ */
+function findPlanuBlocks(content) {
+    const blocks = [];
+    const re = new RegExp(OPEN_MARKER_RE.source, 'g');
+    let match;
+    while ((match = re.exec(content)) !== null) {
+        const id = match[1];
+        if (id === undefined) {
+            continue;
+        }
+        const openEnd = match.index + match[0].length;
+        const closeTag = `<!-- /${id} -->`;
+        const repeatTag = match[0];
+        const closeTagStart = content.indexOf(closeTag, openEnd);
+        const repeatTagStart = content.indexOf(repeatTag, openEnd);
+        const closeStart = [closeTagStart, repeatTagStart]
+            .filter((idx) => idx !== -1)
+            .sort((a, b) => a - b)[0];
+        if (closeStart === undefined) {
+            return null;
+        }
+        const closeLength = closeStart === closeTagStart ? closeTag.length : repeatTag.length;
+        blocks.push({ id, openEnd, closeStart });
+        re.lastIndex = closeStart + closeLength;
+    }
+    return blocks;
+}
+async function scanTier1(absPath, relPath, content) {
+    const blocks = findPlanuBlocks(content);
+    if (blocks === null) {
+        return {
+            kind: 'warning',
+            file: relPath,
+            reason: 'malformed Planu block marker: an opening marker has no matching closing marker',
+        };
+    }
+    const dirty = blocks.some(({ openEnd, closeStart }) => containsContradictoryPhrase(content.slice(openEnd, closeStart)));
+    if (!dirty) {
+        return { kind: 'clean' };
+    }
+    let rewritten = '';
+    let cursor = 0;
+    for (const { openEnd, closeStart } of blocks) {
+        const body = content.slice(openEnd, closeStart);
+        rewritten += content.slice(cursor, openEnd);
+        rewritten += containsContradictoryPhrase(body) ? `\n${REGISTRY.replacementGuidance}\n` : body;
+        cursor = closeStart;
+    }
+    rewritten += content.slice(cursor);
+    await atomicWriteFile(absPath, rewritten);
+    return { kind: 'healed', file: relPath };
+}
+async function scanTier2Or3(absPath, relPath, content) {
+    const phrase = containsContradictoryPhrase(content);
+    if (!phrase) {
+        return { kind: 'clean' };
+    }
+    const strongFingerprint = REGISTRY.legacyFilenameAllowlist.includes(relPath) &&
+        REGISTRY.managedByMarkers.some((marker) => content.includes(marker));
+    if (!strongFingerprint) {
+        return {
+            kind: 'warning',
+            file: relPath,
+            reason: `contains contradictory legacy guidance phrase: "${phrase}"`,
+        };
+    }
+    await atomicWriteFile(`${absPath}.planu-backup`, content);
+    await atomicWriteFile(absPath, `${REGISTRY.replacementGuidance}\n`);
+    return { kind: 'healed', file: relPath };
+}
+async function scanFile(projectPath, relPath) {
+    const absPath = join(projectPath, relPath);
+    let content;
+    try {
+        content = await readFile(absPath, 'utf-8');
+    }
+    catch {
+        return { kind: 'clean' };
+    }
+    // Fail closed if the surface entry (or an ancestor directory, e.g. a
+    // symlinked .claude/rules) resolves outside the project root — never let a
+    // mutation follow a symlink off the repo.
+    try {
+        await resolveContainedProjectFile(projectPath, absPath);
+    }
+    catch {
+        return {
+            kind: 'warning',
+            file: relPath,
+            reason: 'path escapes the project directory (symlink containment check failed)',
+        };
+    }
+    const hasMarkers = OPEN_MARKER_RE.test(content);
+    OPEN_MARKER_RE.lastIndex = 0;
+    return hasMarkers
+        ? scanTier1(absPath, relPath, content)
+        : scanTier2Or3(absPath, relPath, content);
+}
+/**
+ * Scan the bounded set of Planu-installed host guidance surfaces for stale
+ * directives that contradict the current spec.md-only contract, and
+ * neutralize what can be neutralized fail-closed. Never touches files
+ * outside the inventoried scan surface (no repo-wide walk).
+ */
+export async function scanLegacyGuidance(projectPath) {
+    const files = await resolveScanSurface(projectPath);
+    const healed = [];
+    const warnings = [];
+    for (const relPath of files) {
+        const outcome = await scanFile(projectPath, relPath);
+        if (outcome.kind === 'healed') {
+            healed.push(outcome.file);
+        }
+        else if (outcome.kind === 'warning') {
+            warnings.push({ file: outcome.file, reason: outcome.reason });
+        }
+    }
+    return { healed, warnings };
+}
+/** Records a legacy-guidance scan outcome onto an init_project autopilot summary. */
+export function summarizeLegacyGuidanceScan(collector, scan) {
+    if (scan.healed.length > 0) {
+        collector.pushOk('legacy-guidance-healed', `Neutralized stale Planu guidance in: ${scan.healed.join(', ')}`);
+    }
+    if (scan.warnings.length > 0) {
+        collector.pushSkipped('legacy-guidance-warnings', `Left untouched (weak fingerprint, needs manual review): ${scan.warnings
+            .map((w) => w.file)
+            .join(', ')}`);
+    }
+}
+//# sourceMappingURL=legacy-guidance-scanner.js.map

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

@@ -18,13 +18,13 @@ alwaysApply: true
 \`\`\`
 facilitate("what to build") → create_spec → challenge_spec → check_readiness
 → update_status(review) → approve → update_status(approved) → implement
-→ validate (ack) → watch_job (completed) → inspect job.result → update_status(done)
+→ validate (ack) → get_job (poll until 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
+1. Call \`validate\` and capture \`operationId\`, \`projectId\`, and \`workspaceId\`
+2. Poll \`get_job\` with those identifiers 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
 
@@ -54,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: submit \`validate()\`, await \`watch_job()\`, inspect \`job.result.structuredContent\`, then use \`update_status(done)\`
+- Finishing work: submit \`validate()\`, poll \`get_job()\`, inspect \`job.result.structuredContent\`, then use \`update_status(done)\`
 
 ## Mandatory Workflow
 
@@ -64,7 +64,7 @@ Planu enforces Spec Driven Development — spec first, then implement, then vali
 4. \`update_status(specId, "approved")\` — lock the spec
 5. Implement the code
 6. \`validate(specId)\` — submit validation and capture the durable job acknowledgement
-7. \`watch_job(operationId, projectId, workspaceId, cursor)\` — repeat until terminal
+7. \`get_job(operationId, projectId, workspaceId)\` — poll and repeat until terminal
 8. Require \`completed\` and inspect \`job.result.structuredContent\`
 9. \`update_status(specId, "done")\` — mark complete only after a completed passing result
 

package/dist/tools/init-project/planu-workflow-generator.js

@@ -10,7 +10,7 @@ const PLANU_WORKFLOW_CONTENT = `<!-- planu-sdd-workflow -->
 ### Session Start
 1. Call \`planu_status\` — load active specs and git state
 2. If spec is \`implementing\` → resume it before starting new work
-3. Call \`semantic_search\` before starting any new task
+3. Call \`list_specs\` before starting any new task to find related work
 
 ### For ANY task > 5 minutes
 NEVER write production code without an approved spec.
@@ -21,22 +21,11 @@ NEVER write production code without an approved spec.
 ### Session End
 Call \`session_checkpoint\` to save context for the next session.
 
-### For Multiple Specs (3+ parallel work)
-When implementing multiple independent specs simultaneously, use Agent Teams:
-1. Call \`plan_team_distribution\` with spec IDs → auto-assigns file ownership
-2. Call \`generate_teammate_prompt\` for each teammate → isolated context per agent
-3. Spawn N Claude Code agents with the generated prompts
-4. Call \`validate_team_results\` after completion → verify merged code
-
-Use teams when: 3+ specs ready, estimated effort >8h, monorepo with clear module boundaries.
-Quick ref: parallel work → \`plan_team_distribution\` → teammates → \`validate_team_results\`
-
 ### Quick reference
 - New feature → \`facilitate("description")\`
 - Check progress → \`planu_status\`
-- Find related work → \`semantic_search("keywords")\`
+- Find related work → \`list_specs\` and scan titles
 - List pending → \`list_specs\` with status filter
-- Parallel work → \`plan_team_distribution\`
 <!-- /planu-sdd-workflow -->`;
 /**
  * Generate the Planu SDD section for CLAUDE.md.

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

@@ -1,10 +1,30 @@
-import type { FilesystemImportDeps, FilesystemImportFailure, PortableIndexReconciliationResult, SkippedLegacyContract } from '../../types/index.js';
+import type { WorkflowSkillGenerationResult } from '../../types/skill-registry.js';
+import type { FilesystemImportDeps, FilesystemImportFailure, LegacyGuidanceScanResult, PortableIndexReconciliationResult, SkippedLegacyContract } from '../../types/index.js';
+import type { ToolResult } from '../../types/common/primitives.js';
 /** Autopilot-first summary of fatal reconciliation failures: what failed, why, and the next action. */
 export declare function describeReconciliationFailures(failures: FilesystemImportFailure[]): string;
 /** Autopilot-first summary of a successful reconciliation, including any legacy skips. */
 export declare function describeReconciliationSuccess(repositoryFilesChanged: string[], skippedLegacy: SkippedLegacyContract[], strayRepoRemovals?: string[]): string;
 /** Autopilot-first message for a reconciliation outcome, success or fatal-failure. */
 export declare function describeReconciliationOutcome(reconciliation: PortableIndexReconciliationResult, repositoryFilesChanged: string[]): string;
+/**
+ * SPEC-1716: Build the already-initialized `init_project` result, folding the
+ * legacy-guidance scan's healed paths into the reported repository file changes.
+ */
+export declare function buildAlreadyInitializedResult(projectId: string, reconciliation: PortableIndexReconciliationResult, legacyMigratedPaths: readonly string[], refreshedAssets: readonly string[], legacyGuidanceScan: LegacyGuidanceScanResult, projectPath: string, skillSync?: WorkflowSkillGenerationResult | null): ToolResult;
+/** The subset of `MigrationRunResult` (migration-runner.ts) needed to report an authorized migration. */
+interface AuthorizedMigrationSummary {
+    criticalMigrationFailures: unknown[];
+    changedPaths?: string[];
+    migrationReportPath: string | null;
+}
+/**
+ * SPEC-1716: Build the authorized-migration `init_project` result, folding the
+ * legacy-guidance scan's healed paths into the reported repository file changes
+ * the same way the already-initialized fast path does.
+ */
+export declare function buildAuthorizedMigrationResult(projectId: string, projectPath: string, authorizedMigrations: readonly string[], migrationResult: AuthorizedMigrationSummary, legacyGuidanceScan: LegacyGuidanceScanResult): ToolResult;
 /** Rebuild the mutable external index from the repository-owned portable contracts. */
 export declare function reconcilePortableSpecIndex(projectPath: string, projectId: string, deps?: FilesystemImportDeps): Promise<PortableIndexReconciliationResult>;
+export {};
 //# sourceMappingURL=portable-index-reconciler.d.ts.map

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

@@ -156,6 +156,72 @@ export function describeReconciliationOutcome(reconciliation, repositoryFilesCha
         ? describeReconciliationSuccess(repositoryFilesChanged, reconciliation.skippedLegacy, reconciliation.strayRepoRemovals)
         : describeReconciliationFailures(reconciliation.failures);
 }
+/**
+ * SPEC-1716: Build the already-initialized `init_project` result, folding the
+ * legacy-guidance scan's healed paths into the reported repository file changes.
+ */
+export function buildAlreadyInitializedResult(projectId, reconciliation, legacyMigratedPaths, refreshedAssets, legacyGuidanceScan, projectPath, skillSync = null) {
+    const repositoryFilesChanged = [...refreshedAssets, ...legacyGuidanceScan.healed];
+    const baseText = describeReconciliationOutcome(reconciliation, [...refreshedAssets]);
+    const healedGuidanceSuffix = legacyGuidanceScan.healed.length === 0
+        ? ''
+        : ` Healed stale legacy guidance in: ${legacyGuidanceScan.healed.join(', ')}.`;
+    const skillSyncSuffix = skillSync === null
+        ? ''
+        : ` Refreshed ${String(skillSync.written.length)} workflow skill(s), left ${String(skillSync.userModified.length)} user-modified skill(s) untouched.`;
+    return {
+        content: [{ type: 'text', text: baseText + healedGuidanceSuffix + skillSyncSuffix }],
+        structuredContent: {
+            projectId,
+            ...(reconciliation.failures.length === 0 ? { projectPath } : {}),
+            isUpdate: true,
+            repositoryFilesChanged,
+            authorizedMigrations: [],
+            importedSpecIds: reconciliation.importedSpecIds,
+            failures: reconciliation.failures,
+            skippedLegacy: reconciliation.skippedLegacy,
+            strayRepoRemovals: reconciliation.strayRepoRemovals,
+            migratedLegacyPaths: legacyMigratedPaths,
+            legacyGuidanceHealed: legacyGuidanceScan.healed,
+            legacyGuidanceWarnings: legacyGuidanceScan.warnings,
+            skillsWritten: skillSync?.written.length ?? 0,
+            skillsUserModified: skillSync?.userModified.length ?? 0,
+        },
+        ...(reconciliation.failures.length > 0 ? { isError: true } : {}),
+    };
+}
+/**
+ * SPEC-1716: Build the authorized-migration `init_project` result, folding the
+ * legacy-guidance scan's healed paths into the reported repository file changes
+ * the same way the already-initialized fast path does.
+ */
+export function buildAuthorizedMigrationResult(projectId, projectPath, authorizedMigrations, migrationResult, legacyGuidanceScan) {
+    const hasCriticalFailures = migrationResult.criticalMigrationFailures.length > 0;
+    const healedGuidanceSuffix = legacyGuidanceScan.healed.length === 0
+        ? ''
+        : ` Healed stale legacy guidance in: ${legacyGuidanceScan.healed.join(', ')}.`;
+    const baseText = hasCriticalFailures
+        ? `Authorized migration completed with ${String(migrationResult.criticalMigrationFailures.length)} blocking issue(s).`
+        : 'Authorized planu-spec-format-v1 migration completed.';
+    return {
+        content: [{ type: 'text', text: baseText + healedGuidanceSuffix }],
+        structuredContent: {
+            projectId,
+            projectPath,
+            isUpdate: true,
+            authorizedMigrations,
+            repositoryFilesChanged: [
+                ...(migrationResult.changedPaths ?? []),
+                ...legacyGuidanceScan.healed,
+            ],
+            migrationReportPath: migrationResult.migrationReportPath,
+            criticalMigrationFailures: migrationResult.criticalMigrationFailures,
+            legacyGuidanceHealed: legacyGuidanceScan.healed,
+            legacyGuidanceWarnings: legacyGuidanceScan.warnings,
+        },
+        ...(hasCriticalFailures ? { isError: true } : {}),
+    };
+}
 /** Rebuild the mutable external index from the repository-owned portable contracts. */
 export async function reconcilePortableSpecIndex(projectPath, projectId, deps = {
     listSpecs: specStore.listSpecs,

package/dist/tools/init-project/rules-generator.d.ts

@@ -1,14 +1,3 @@
-export declare function generateAgentTeamsRulesContent(): string;
-/**
- * Write .claude/rules/agent-teams.md to the target project.
- * Always overwrites to keep the content up to date.
- */
-export declare function generateAgentTeamsRules(projectPath: string): Promise<void>;
-/**
- * Write .claude/rules/agent-teams.md only if it does not exist yet.
- * @returns true if the file was created, false if it already existed.
- */
-export declare function generateAgentTeamsRulesIfMissing(projectPath: string): Promise<boolean>;
 /**
  * Write .claude/rules/planu-workflow.md to the target project.
  * Always overwrites to keep the content up to date.

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

@@ -18,12 +18,12 @@ 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 (ack) → watch_job (completed) → inspect job.result → done\`
+Flow: \`facilitate → create_spec → challenge_spec → check_readiness → approve → implement → validate (ack) → get_job (poll until 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.
+1. Call \`validate\` and capture \`operationId\`, \`projectId\`, and \`workspaceId\` from the acknowledgement.
+2. Poll \`get_job\` with those identifiers. 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.
 
@@ -60,7 +60,7 @@ Any new feature, bug fix, refactor, integration, or task > 5 min.
 |------|------|
 | New feature | \`facilitate("what to build")\` |
 | Project status | \`planu_status\` |
-| Find related specs | \`semantic_search("keywords")\` |
+| Find related specs | \`list_specs\` and scan titles |
 | List approved work | \`list_specs\` with \`status: approved\` |
 | Mark done | \`update_status\` → \`done\` |
 | Verify | \`validate\` |
@@ -102,87 +102,6 @@ Set \`CLAUDE_CODE_SUBAGENT_MODEL=haiku\` in \`.env\` for automatic haiku on all
 - Keep output < 500 tokens for read operations, < 200 tokens for write confirmations
 - After every tool call: explain what happened in simple terms
 `;
-const AGENT_TEAMS_RULES_PATH = '.claude/rules/agent-teams.md';
-export function generateAgentTeamsRulesContent() {
-    return `# Agent Teams (MANDATORY when 3+ specs in parallel)
-
-This rule file is auto-generated by Planu \`init_project\`. Do not edit manually — re-run \`init_project\` to update.
-
-## When to Use Agent Teams
-
-Use Agent Teams when ALL of the following apply:
-- 3+ independent specs are ready to implement simultaneously
-- Estimated total effort > 8h
-- Specs touch different modules/packages (clear file ownership boundaries)
-- Monorepo or multi-layer architecture with well-defined interfaces
-
-## File Ownership (MANDATORY)
-
-**Two teammates MUST NEVER modify the same file.** This is non-negotiable.
-
-- \`plan_team_distribution\` auto-assigns exclusive file ownership per agent
-- Review the distribution before spawning — resolve any conflicts first
-- If two specs require the same shared file, implement them sequentially, not in parallel
-
-## Workflow
-
-\`\`\`
-1. plan_team_distribution   # input: spec IDs → output: file ownership map
-2. generate_teammate_prompt # input: teammate assignment → output: isolated prompt
-3. spawn N agents           # claude -p "<prompt>" for each teammate (run in parallel)
-4. validate_team_results    # input: projectPath → verifies merged code integrity
-\`\`\`
-
-## Available Team Patterns
-
-- **implement-and-test** — one agent implements, another writes tests (zero shared files)
-- **full-stack** — frontend and backend agents with a contract-first API boundary
-- **research-then-build** — researcher gathers context first, builder implements after
-- **parallel-specs** — N agents implement N fully independent specs simultaneously
-
-## Quick Reference
-
-| Goal | Tool |
-|------|------|
-| Plan team distribution | \`plan_team_distribution\` with spec IDs array |
-| Get teammate context | \`generate_teammate_prompt\` with assignment object |
-| Validate merged result | \`validate_team_results\` after all agents complete |
-
-## Prohibited Patterns
-
-- NEVER spawn teammates without running \`plan_team_distribution\` first
-- NEVER assign the same file to two different teammates
-- NEVER skip \`validate_team_results\` after parallel implementation
-- NEVER use Agent Teams for 1-2 specs — sequential is faster and safer
-`;
-}
-/**
- * Write .claude/rules/agent-teams.md to the target project.
- * Always overwrites to keep the content up to date.
- */
-export async function generateAgentTeamsRules(projectPath) {
-    const rulesPath = join(projectPath, AGENT_TEAMS_RULES_PATH);
-    const rulesDir = join(projectPath, '.claude/rules');
-    await mkdir(rulesDir, { recursive: true });
-    const content = generateAgentTeamsRulesContent();
-    assertEnglishOnlyArtifactText(content, 'rule');
-    await writeFile(rulesPath, content, 'utf-8');
-}
-/**
- * Write .claude/rules/agent-teams.md only if it does not exist yet.
- * @returns true if the file was created, false if it already existed.
- */
-export async function generateAgentTeamsRulesIfMissing(projectPath) {
-    const rulesPath = join(projectPath, AGENT_TEAMS_RULES_PATH);
-    try {
-        await access(rulesPath);
-        return false; // already exists
-    }
-    catch {
-        await generateAgentTeamsRules(projectPath);
-        return true;
-    }
-}
 /**
  * Write .claude/rules/planu-workflow.md to the target project.
  * Always overwrites to keep the content up to date.

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

@@ -22,7 +22,6 @@ export interface ScaffoldWriteResult {
     planuWorkflowInjected: boolean;
     planuHooksConfigured: boolean;
     planuRulesWritten: boolean;
-    agentTeamsRulesWritten: boolean;
     modeRulesWritten: boolean;
     responseStyleRulesWritten: boolean;
     compactSkillWritten: boolean;

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

@@ -8,7 +8,7 @@ import { runGitSetup } from './git-setup.js';
 import { generateAndWriteRules } from './lifecycle-helpers.js';
 import { generatePlanuSection, injectPlanuSection } from './planu-workflow-generator.js';
 import { configurePlanuHooks } from './hooks-configurator.js';
-import { generateWorkflowRulesIfMissing, generateAgentTeamsRulesIfMissing, generateModeRulesIfMissing, generateResponseStyleRulesIfMissing, } from './rules-generator.js';
+import { generateWorkflowRulesIfMissing, generateModeRulesIfMissing, generateResponseStyleRulesIfMissing, } from './rules-generator.js';
 import { generateCompactSkillIfMissing } from './skills-writer.js';
 import { generateFindSkillsIfMissing } from './find-skills-writer.js';
 import { injectPlanuAutoStage } from '../../engine/git-hook-injector.js';
@@ -120,16 +120,6 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
             /* best-effort */
         }
     }
-    // SPEC-291: Write .claude/rules/agent-teams.md if missing (best-effort)
-    let agentTeamsRulesWritten = false;
-    if (shouldWriteClaudeAssets) {
-        try {
-            agentTeamsRulesWritten = await generateAgentTeamsRulesIfMissing(projectPath);
-        }
-        catch {
-            /* best-effort */
-        }
-    }
     // SPEC-494: Write .claude/rules/planu-modes.md if missing (best-effort)
     let modeRulesWritten = false;
     if (shouldWriteClaudeAssets) {
@@ -394,7 +384,6 @@ export async function runScaffoldWriter(projectPath, projectId, knowledge, recom
         planuWorkflowInjected,
         planuHooksConfigured,
         planuRulesWritten,
-        agentTeamsRulesWritten,
         modeRulesWritten,
         responseStyleRulesWritten,
         compactSkillWritten,

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

@@ -4,12 +4,6 @@ export interface JobToolIdentityInput {
     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

@@ -52,6 +52,7 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 });
 import { DurableJobRuntime, publicJobCursor } from '../../engine/execution/job-runtime.js';
 import { scheduleValidateJobExecution } from '../../engine/execution/validate-job-executor.js';
+import { schedulePackageHandoffJobExecution } from '../../engine/execution/package-handoff-job-executor.js';
 import { isValidationReceiptPendingIntent, parseValidationReceiptPendingCheckpoint, } from '../../types/durable-validation.js';
 import { redactText } from '../../security/redactor.js';
 import { getRuntimePolicy } from '../../engine/runtime-policy.js';
@@ -97,62 +98,34 @@ export function handleGetJob(input) {
         __disposeResources(env_1);
     }
 }
-export async function handleWatchJob(input) {
+export function handleRestartJob(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') {
+        const kind = job.payload && typeof job.payload === 'object'
+            ? job.payload.kind
+            : undefined;
+        if (kind === 'validate') {
             scheduleValidateJobExecution(job.projectId, job.workspaceId);
         }
+        else if (kind === 'package-handoff') {
+            schedulePackageHandoffJobExecution(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;
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
     }
     finally {
-        __disposeResources(env_4);
+        __disposeResources(env_2);
     }
 }
 //# sourceMappingURL=handlers.js.map