@blxzer/pactile 0.5.0 → 0.6.0-beta.4

package/dist/commands/init.js

@@ -8,159 +8,22 @@ import figlet from "figlet";
 import inquirer from "inquirer";
 import { createWorkflowStructure } from "../configurators/workflow.js";
 import { getInitToolChoices } from "../configurators/index.js";
-import { getPythonCommandForPlatform, setResolvedPythonCommand, } from "../configurators/shared.js";
 import { DIR_NAMES, FILE_NAMES, PATHS } from "../constants/paths.js";
 import { VERSION } from "../constants/version.js";
 import { setWriteMode, startRecordingWrites, stopRecordingWrites, } from "../utils/file-writer.js";
-import { applyKernelCreate, applyKernelStart, writeWaveCConfirmed, } from "@blxzer/pactile-core/task";
-import { PACTILE_ENVIRONMENT_KEYS, readPactileEnvironment, } from "@blxzer/pactile-core";
-import { emptyTaskJson } from "../utils/task-json.js";
+import { writeWaveCConfirmed, createTaskKernel, readTaskKernel, } from "../core/task/index.js";
+import { canonicalProjectRoot } from "../core/task/task-kernel-paths.js";
+import { initializeDeveloper, readDeveloper } from "../utils/developer.js";
 import { detectProjectType, detectMonorepo, sanitizePkgName, } from "../utils/project-detector.js";
 import { initializeHashes, removeHash } from "../utils/template-hash.js";
 import { NATIVE_WORKFLOW_ID, resolveWorkflowTemplate, } from "../utils/workflow-resolver.js";
 import { isCwdHomedir, homedirGuardMessage, homedirBypassEnabled, } from "../utils/cwd-guard.js";
 import { fetchTemplateIndex, probeRegistryIndex, downloadTemplateById, downloadRegistryDirect, parseRegistrySource, TIMEOUTS, TEMPLATE_INDEX_URL, } from "../utils/template-fetcher.js";
-import { setupProxy, maskProxyUrl } from "../utils/proxy.js";
 import { reportInitReadiness, snapshotReadinessForRollout, } from "../utils/readiness.js";
 import { getProjectCapability, getProjectCapabilityChoices, loadProjectCapabilities, parseProjectCapabilities, writeProjectCapabilityFiles, } from "../utils/project-capabilities.js";
 import { collectCanonicalGenerationFiles, collectLegacyCstlLifecycleFiles, discoverCanonicalGenerationPaths, installedPactilePlatforms, materializeCanonicalGeneration, materializePreparedLegacyUserState, prepareLegacyCstlImport, readLegacyCstlVersion, runLifecycleCommand, seedCanonicalBuildRoot, } from "../pactile/lifecycle/index.js";
 import { InstallStateStore } from "../pactile/runtime/stores.js";
 import { inspectLegacyInitContext, legacyImportPreparedMessage, } from "../pactile/compat/init-context.js";
-const MIN_PYTHON_MAJOR = 3;
-const MIN_PYTHON_MINOR = 9;
-const PYTHON_VERSION_RE = /Python (\d+)\.(\d+)/;
-export function isSupportedPythonVersion(versionOutput) {
-    const match = versionOutput.match(PYTHON_VERSION_RE);
-    if (!match)
-        return false;
-    const major = Number(match[1]);
-    const minor = Number(match[2]);
-    return (major > MIN_PYTHON_MAJOR ||
-        (major === MIN_PYTHON_MAJOR && minor >= MIN_PYTHON_MINOR));
-}
-function detectPythonVersion(command) {
-    try {
-        return execSync(`${command} --version`, {
-            encoding: "utf-8",
-            stdio: "pipe",
-        }).trim();
-    }
-    catch (err) {
-        const code = err?.code;
-        if (code === "EPERM" || code === "EACCES") {
-            return "sandbox-restricted";
-        }
-        return null;
-    }
-}
-export function requireSupportedPython(command) {
-    // Final escape hatch — set when the user knows python3 is on PATH but
-    // the probe keeps failing for environment-specific reasons.
-    if (readPactileEnvironment(PACTILE_ENVIRONMENT_KEYS.skipPythonCheck) === "1") {
-        return `version check skipped (PACTILE_SKIP_PYTHON_CHECK=1)`;
-    }
-    const versionOutput = detectPythonVersion(command);
-    if (versionOutput === "sandbox-restricted") {
-        console.warn(chalk.yellow(`⚠ Python version check skipped — sandboxed environment blocked ` +
-            `child_process spawn (EPERM/EACCES). Assuming "${command}" is on ` +
-            `PATH. If init fails later, re-run on the host or set ` +
-            `PACTILE_SKIP_PYTHON_CHECK=1.`));
-        return `version unknown (sandbox-restricted)`;
-    }
-    if (!versionOutput) {
-        throw new Error(`Python command "${command}" not found. Pactile init requires Python ≥ 3.9.`);
-    }
-    if (!isSupportedPythonVersion(versionOutput)) {
-        throw new Error(`${versionOutput} detected via "${command}", but Pactile init requires Python ≥ 3.9.`);
-    }
-    return versionOutput;
-}
-/**
- * Candidate Python command list per platform.
- *
- * Windows: `python` is the usual python.org installer choice, but Microsoft
- * Store ships `python3`, and the `py` launcher is `py -3`. We try all three
- * before giving up — fixes #236 where users with only `python3` (not
- * `python`) had `pactile init` fail outright.
- *
- * Non-Windows: `python3` is canonical; `python` is a fallback for systems
- * where Python 3 is the only Python and is named `python` (some Arch
- * configs, conda envs).
- */
-const PYTHON_CANDIDATES = {
-    win32: ["python", "python3", "py -3"],
-    other: ["python3", "python"],
-};
-/**
- * Detect a working Python ≥ 3.9 command on the host platform.
- *
- * Honors `PACTILE_PYTHON_CMD` (explicit override, no probe) and
- * `PACTILE_SKIP_PYTHON_CHECK=1` (skip probe, trust platform default).
- *
- * Otherwise tries each candidate in `PYTHON_CANDIDATES` in order and returns
- * the first whose `--version` matches `Python ≥ 3.9`. Caches the result via
- * `setResolvedPythonCommand` so all downstream template / configurator
- * writes pick up the resolved value.
- *
- * Throws a helpful, Windows-aware error if no candidate works.
- */
-export function resolveSupportedPython() {
-    // Explicit override — user knows their environment.
-    const override = readPactileEnvironment(PACTILE_ENVIRONMENT_KEYS.pythonCommand)?.trim();
-    if (override) {
-        setResolvedPythonCommand(override);
-        return { command: override, version: "set via PACTILE_PYTHON_CMD" };
-    }
-    // Skip probe entirely.
-    if (readPactileEnvironment(PACTILE_ENVIRONMENT_KEYS.skipPythonCheck) === "1") {
-        const fallback = getPythonCommandForPlatform();
-        setResolvedPythonCommand(fallback);
-        return {
-            command: fallback,
-            version: "version check skipped (PACTILE_SKIP_PYTHON_CHECK=1)",
-        };
-    }
-    const candidates = process.platform === "win32"
-        ? PYTHON_CANDIDATES.win32
-        : PYTHON_CANDIDATES.other;
-    const probeFailures = [];
-    for (const candidate of candidates) {
-        const probe = detectPythonVersion(candidate);
-        if (probe === "sandbox-restricted") {
-            console.warn(chalk.yellow(`⚠ Python version check skipped — sandboxed environment blocked ` +
-                `child_process spawn (EPERM/EACCES). Assuming "${candidate}" is ` +
-                `on PATH. If init fails later, re-run on the host or set ` +
-                `PACTILE_SKIP_PYTHON_CHECK=1.`));
-            setResolvedPythonCommand(candidate);
-            return {
-                command: candidate,
-                version: "version unknown (sandbox-restricted)",
-            };
-        }
-        if (!probe) {
-            probeFailures.push(`${candidate}: not found`);
-            continue;
-        }
-        if (!isSupportedPythonVersion(probe)) {
-            probeFailures.push(`${candidate}: ${probe} (< 3.9)`);
-            continue;
-        }
-        setResolvedPythonCommand(candidate);
-        return { command: candidate, version: probe };
-    }
-    const isWindows = process.platform === "win32";
-    const installHint = isWindows
-        ? `Install Python ≥ 3.9 from https://www.python.org/downloads/windows/ — make sure ` +
-            `"Add Python to PATH" is checked in the installer. Or, if Python is ` +
-            `installed under a different name, set PACTILE_PYTHON_CMD=<your-cmd> ` +
-            `before re-running init (e.g. \`set PACTILE_PYTHON_CMD=py -3\`).`
-        : `Install Python ≥ 3.9 from https://www.python.org/downloads/ or via your ` +
-            `package manager. Or set PACTILE_PYTHON_CMD=<your-cmd> before re-running.`;
-    throw new Error(`No supported Python command found. Tried: ${candidates.join(", ")}.\n` +
-        `Probe results:\n  ${probeFailures.join("\n  ")}\n\n` +
-        `Pactile init requires Python ≥ 3.9. ${installHint}\n` +
-        `Last-resort escape hatch: set PACTILE_SKIP_PYTHON_CHECK=1 to skip the probe entirely.`);
-}
 // =============================================================================
 // Bootstrap Task Creation
 // =============================================================================
@@ -183,48 +46,368 @@ export function slugifyDeveloperName(name) {
     return slug || "user";
 }
 /**
- * Write a task skeleton (task.json + prd.md).
- *
- * Idempotent: if the task dir already exists, returns true without touching
- * anything. Shared by both creator bootstrap and joiner onboarding flows.
+ * Task Kernel IDs are lowercase ASCII slugs, while legacy task directory names
+ * intentionally preserve Unicode developer names. Encode non-ASCII code points
+ * so both identities remain deterministic without changing an existing path.
  */
-function writeTaskSkeleton(cwd, taskName, taskJson, prdContent) {
-    const taskDir = path.join(cwd, PATHS.TASKS, taskName);
-    if (fs.existsSync(taskDir))
-        return true; // idempotent
+function taskKernelIdForDirectoryName(taskName) {
+    let encoded = "";
+    for (const character of taskName.toLowerCase()) {
+        if (/[a-z0-9]/u.test(character) || character === "-") {
+            encoded += character;
+        }
+        else {
+            encoded += `-u${character.codePointAt(0)?.toString(16) ?? "0"}-`;
+        }
+    }
+    return encoded.replace(/-+/gu, "-").replace(/^-|-$/gu, "") || "task";
+}
+const INIT_TASK_MARKER_TEXT = "Task creation was interrupted; retry pactile init.\n";
+const INIT_JOINER_MARKER_PREFIX = `${INIT_TASK_MARKER_TEXT}joiner:v1:`;
+const MAX_INIT_JOINER_DEVELOPER_NAME_LENGTH = 256;
+const MAX_INIT_TASK_MARKER_BYTES = 2048;
+function containsInitJoinerControlCharacters(value) {
+    for (const character of value) {
+        const codePoint = character.codePointAt(0) ?? 0;
+        if (codePoint < 0x20 || codePoint === 0x7f)
+            return true;
+    }
+    return false;
+}
+function normalizeInitJoinerDeveloperName(value, taskName) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_INIT_JOINER_DEVELOPER_NAME_LENGTH ||
+        value.trim() !== value ||
+        value === "." ||
+        value === ".." ||
+        containsInitJoinerControlCharacters(value) ||
+        Buffer.byteLength(value, "utf8") > MAX_INIT_JOINER_DEVELOPER_NAME_LENGTH * 4 ||
+        taskName !== `00-join-${slugifyDeveloperName(value)}`) {
+        return null;
+    }
+    return value;
+}
+function initTaskMarkerContent(taskName, developerName) {
+    if (!developerName)
+        return INIT_TASK_MARKER_TEXT;
+    const normalizedName = normalizeInitJoinerDeveloperName(developerName.trim(), taskName);
+    if (!normalizedName)
+        return INIT_TASK_MARKER_TEXT;
+    return `${INIT_JOINER_MARKER_PREFIX}${JSON.stringify(normalizedName)}\n`;
+}
+function pathExists(pathname) {
+    return fs.lstatSync(pathname, { throwIfNoEntry: false }) !== undefined;
+}
+function assertSafeInitTaskPaths(cwd, extraDirectories = []) {
+    const projectRoot = canonicalProjectRoot(cwd, cwd);
+    const tasksRoot = path.resolve(projectRoot, PATHS.TASKS);
+    const tasksRelative = path.relative(projectRoot, tasksRoot);
+    if (!tasksRelative ||
+        tasksRelative === ".." ||
+        tasksRelative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(tasksRelative)) {
+        throw new Error("Init Task root must stay inside the canonical project root");
+    }
+    const pactileRoot = path.resolve(projectRoot, DIR_NAMES.WORKFLOW);
+    const checkedDirectories = [pactileRoot, tasksRoot, ...extraDirectories];
+    for (const directory of checkedDirectories) {
+        const relative = path.relative(tasksRoot, directory);
+        if (directory !== pactileRoot &&
+            directory !== tasksRoot &&
+            (!relative ||
+                relative === ".." ||
+                relative.startsWith(`..${path.sep}`) ||
+                path.isAbsolute(relative))) {
+            throw new Error("Init Task staging path must stay inside .pactile/tasks");
+        }
+        const entry = fs.lstatSync(directory, { throwIfNoEntry: false });
+        if (!entry)
+            continue;
+        if (entry.isSymbolicLink() ||
+            !entry.isDirectory() ||
+            fs.realpathSync(directory) !== directory) {
+            throw new Error("Init Task paths must be real directories inside the project");
+        }
+    }
+    return tasksRoot;
+}
+function readInitTaskMarker(cwd, taskName) {
+    try {
+        const tasksRoot = assertSafeInitTaskPaths(cwd);
+        const marker = path.join(tasksRoot, `.pending-${taskName}`);
+        const entry = fs.lstatSync(marker);
+        if (!entry.isFile() ||
+            entry.isSymbolicLink() ||
+            entry.size > MAX_INIT_TASK_MARKER_BYTES) {
+            return null;
+        }
+        const contents = fs.readFileSync(marker, "utf8");
+        if (contents === INIT_TASK_MARKER_TEXT)
+            return { developerName: null };
+        if (!contents.startsWith(INIT_JOINER_MARKER_PREFIX) ||
+            !contents.endsWith("\n")) {
+            return null;
+        }
+        const encodedName = contents.slice(INIT_JOINER_MARKER_PREFIX.length, -1);
+        let parsedName;
+        try {
+            parsedName = JSON.parse(encodedName);
+        }
+        catch {
+            return null;
+        }
+        const developerName = normalizeInitJoinerDeveloperName(parsedName, taskName);
+        return developerName ? { developerName } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function hasInitTaskMarker(cwd, taskName) {
+    return readInitTaskMarker(cwd, taskName) !== null;
+}
+function readPendingJoinerMarkers(cwd) {
     try {
-        fs.mkdirSync(taskDir, { recursive: true });
-        const created = applyKernelCreate({
-            taskDir,
-            actor: "pactile init",
-            idempotencyKey: `init:${taskName}`,
-            record: { ...taskJson, status: "planning" },
-            evidence: "pactile init skeleton",
+        const tasksRoot = assertSafeInitTaskPaths(cwd);
+        if (!pathExists(tasksRoot))
+            return [];
+        const taskNames = fs
+            .readdirSync(tasksRoot)
+            .filter((entry) => entry.startsWith(".pending-00-join-"))
+            .map((entry) => entry.slice(".pending-".length));
+        return taskNames.map((taskName) => {
+            const marker = readInitTaskMarker(cwd, taskName);
+            return {
+                taskName,
+                developerName: marker?.developerName ?? null,
+                valid: marker !== null,
+            };
         });
-        if (taskJson.status === "in_progress") {
-            applyKernelStart({
-                taskDir,
-                expectedRevision: created.kernel.revision,
-                actor: "pactile init",
-                idempotencyKey: `init-start:${taskName}`,
-                record: { ...taskJson, status: "in_progress" },
-                evidence: "pactile init skeleton start",
+    }
+    catch {
+        return [];
+    }
+}
+function readPendingJoinerDeveloperName(cwd) {
+    const markers = readPendingJoinerMarkers(cwd);
+    if (markers.length !== 1)
+        return null;
+    return markers[0].developerName;
+}
+function clearInitTaskMarker(cwd, taskName) {
+    if (hasInitTaskMarker(cwd, taskName)) {
+        try {
+            const tasksRoot = assertSafeInitTaskPaths(cwd);
+            fs.unlinkSync(path.join(tasksRoot, `.pending-${taskName}`));
+        }
+        catch {
+            // A missing, unreadable, or user-owned marker is left untouched.
+        }
+    }
+}
+function ensureInitTaskMarker(cwd, taskName, developerName) {
+    try {
+        let tasksRoot = assertSafeInitTaskPaths(cwd);
+        fs.mkdirSync(tasksRoot, { recursive: true });
+        tasksRoot = assertSafeInitTaskPaths(cwd);
+        const marker = path.join(tasksRoot, `.pending-${taskName}`);
+        const markerContent = initTaskMarkerContent(taskName, developerName);
+        try {
+            fs.writeFileSync(marker, markerContent, {
+                encoding: "utf8",
+                flag: "wx",
             });
+            return true;
         }
-        fs.writeFileSync(path.join(taskDir, FILE_NAMES.PRD), prdContent, "utf-8");
-        return true;
+        catch (error) {
+            if (error.code !== "EEXIST")
+                return false;
+            const existing = readInitTaskMarker(cwd, taskName);
+            if (!existing)
+                return false;
+            if (!developerName)
+                return true;
+            const normalizedName = normalizeInitJoinerDeveloperName(developerName.trim(), taskName);
+            if (!normalizedName)
+                return existing.developerName === null;
+            if (existing.developerName === normalizedName)
+                return true;
+            if (existing.developerName !== null)
+                return false;
+            // Upgrade only the exact legacy sentinel owned by init. A malformed or
+            // user-edited marker never reaches this branch because the reader rejects it.
+            fs.writeFileSync(marker, markerContent, {
+                encoding: "utf8",
+                flag: "w",
+            });
+            return readInitTaskMarker(cwd, taskName)?.developerName === normalizedName;
+        }
+    }
+    catch {
+        // A conflicting, unreadable, or unwritable marker path is never replaced.
+        return false;
+    }
+}
+function recordInitTaskFailure(cwd, taskName) {
+    ensureInitTaskMarker(cwd, taskName);
+}
+function isCompleteExistingInitTask(cwd, taskName, taskId) {
+    const taskDir = path.join(cwd, PATHS.TASKS, taskName);
+    try {
+        const entry = fs.lstatSync(taskDir);
+        if (!entry.isDirectory() || entry.isSymbolicLink())
+            return false;
+        const prd = fs.readFileSync(path.join(taskDir, FILE_NAMES.PRD), "utf8");
+        if (!prd.trim())
+            return false;
+        const read = readTaskKernel({ root: cwd, taskDir, cwd });
+        if (read.kind === "task-kernel-v2") {
+            return (read.kernel.identity.taskId === taskId &&
+                read.kernel.definition.taskId === taskId);
+        }
+        // Keep complete historical V1 tasks in place for the explicit migration
+        // flow. A task.json without a persisted, matching Kernel is not complete.
+        const taskJson = JSON.parse(fs.readFileSync(path.join(taskDir, FILE_NAMES.TASK_JSON), "utf8"));
+        const legacyKernel = read.kernel.kernel;
+        const projection = legacyKernel.projection;
+        return (read.kernel.persisted &&
+            legacyKernel.identity.taskId === taskName &&
+            projection !== null &&
+            taskJson.id === taskName &&
+            taskJson.status === projection.status &&
+            projection.record.id === taskName &&
+            projection.record.status === projection.status);
     }
     catch {
         return false;
     }
 }
+function removeInitTaskStaging(stagingRoot, stagingDir) {
+    const relative = path.relative(stagingRoot, path.resolve(stagingDir));
+    if (!relative ||
+        relative === ".." ||
+        relative.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relative) ||
+        fs.lstatSync(stagingDir).isSymbolicLink()) {
+        throw new Error("Unsafe init Task staging cleanup target");
+    }
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+}
 /**
- * Compute the bootstrap checklist items (previously stored as structured
- * `subtasks: [{name, status}]` in task.json). Per task 04-21-task-schema-unify
- * (D1), these live as markdown `- [ ]` items in prd.md instead, so task.json
- * stays canonical with `subtasks: string[]` (child task dir names, same as
- * task_store.py).
+ * Publish a complete V2 Define Task (kernel.json + prd.md).
+ *
+ * A complete existing task is kept. A partial one is reported for recovery,
+ * never silently treated as a successful init. Historical V1 records are
+ * preserved for the explicit migration flow and are never rewritten here.
  */
+function writeTaskSkeleton(cwd, taskName, definition, actor, prdContent) {
+    let tasksRoot = null;
+    let stagingRoot = null;
+    let stagingDir = null;
+    let createdStagingRoot = false;
+    let committed = false;
+    try {
+        tasksRoot = assertSafeInitTaskPaths(cwd);
+        stagingRoot = path.join(tasksRoot, ".creating");
+        if (pathExists(path.join(tasksRoot, taskName))) {
+            if (!isCompleteExistingInitTask(cwd, taskName, definition.taskId)) {
+                throw new Error(`Task already exists or needs recovery: ${taskName}`);
+            }
+            clearInitTaskMarker(cwd, taskName);
+            return true;
+        }
+        fs.mkdirSync(tasksRoot, { recursive: true });
+        assertSafeInitTaskPaths(cwd);
+        try {
+            fs.mkdirSync(stagingRoot);
+            createdStagingRoot = true;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const existingStagingRoot = fs.lstatSync(stagingRoot);
+            if (!existingStagingRoot.isDirectory() ||
+                existingStagingRoot.isSymbolicLink()) {
+                throw new Error("Init Task staging path must be a directory");
+            }
+        }
+        assertSafeInitTaskPaths(cwd, [stagingRoot]);
+        stagingDir = fs.mkdtempSync(path.join(stagingRoot, `${taskName}-`));
+        assertSafeInitTaskPaths(cwd, [stagingRoot, stagingDir]);
+        fs.writeFileSync(path.join(stagingDir, FILE_NAMES.PRD), prdContent, {
+            encoding: "utf8",
+            flag: "wx",
+        });
+        const created = createTaskKernel({
+            root: cwd,
+            taskDir: stagingDir,
+            definition,
+            actor,
+            idempotencyKey: `init-v2:${definition.taskId}`,
+            cwd,
+        });
+        if (created.kernel.phase !== "define" ||
+            created.kernel.runs.length !== 0 ||
+            created.kernel.reviews.length !== 0 ||
+            created.kernel.closure !== null) {
+            throw new Error("Init Task did not produce the expected V2 Define state");
+        }
+        const verified = readTaskKernel({ root: cwd, taskDir: stagingDir, cwd });
+        if (verified.kind !== "task-kernel-v2" ||
+            verified.kernel.identity.taskId !== definition.taskId ||
+            verified.kernel.definition.deliveryLevel !== definition.deliveryLevel ||
+            verified.kernel.definition.dependencies.length !== 0 ||
+            verified.kernel.phase !== "define" ||
+            verified.kernel.runs.length !== 0 ||
+            verified.kernel.reviews.length !== 0 ||
+            verified.kernel.closure !== null) {
+            throw new Error("Init Task failed V2 Kernel read-back validation");
+        }
+        assertSafeInitTaskPaths(cwd, [stagingRoot, stagingDir]);
+        const taskDir = path.join(tasksRoot, taskName);
+        if (pathExists(taskDir))
+            throw new Error(`Task already exists: ${taskName}`);
+        fs.renameSync(stagingDir, taskDir);
+        stagingDir = null;
+        committed = true;
+        clearInitTaskMarker(cwd, taskName);
+        return true;
+    }
+    catch {
+        recordInitTaskFailure(cwd, taskName);
+        return false;
+    }
+    finally {
+        if (!committed &&
+            stagingRoot &&
+            stagingDir &&
+            pathExists(stagingDir)) {
+            try {
+                assertSafeInitTaskPaths(cwd, [stagingRoot, stagingDir]);
+                removeInitTaskStaging(stagingRoot, stagingDir);
+            }
+            catch {
+                // Leave unexpected staging state for inspection; the marker remains.
+            }
+        }
+        if (createdStagingRoot && stagingRoot && pathExists(stagingRoot)) {
+            try {
+                assertSafeInitTaskPaths(cwd, [stagingRoot]);
+                const currentStagingRoot = fs.lstatSync(stagingRoot);
+                if (currentStagingRoot.isDirectory() &&
+                    !currentStagingRoot.isSymbolicLink() &&
+                    fs.readdirSync(stagingRoot).length === 0) {
+                    fs.rmdirSync(stagingRoot);
+                }
+            }
+            catch {
+                // Preserve unexpected or user-modified paths during cleanup.
+            }
+        }
+    }
+}
+/** Build the human-readable checklist mirrored by the bootstrap Task's AC. */
 function getBootstrapChecklistItems(projectType, packages) {
     if (packages && packages.length > 0) {
         const items = packages.map((pkg) => `Fill guidelines for ${pkg.name}`);
@@ -253,25 +436,25 @@ function renderCapabilityReadinessSection(selectedCapabilities) {
         return `- [ ] \`${capability.id}\` — ${capability.title}. Verify the generated MCP/config path is usable before claiming it in task evidence.`;
     })
         .join("\n");
-    return `
-## Capability readiness (required before archive)
-
-Init selected optional project capabilities for this repo. Treat them as
-\`pending\` until you verify they work in this checkout.
-
-${checklist}
-
-- Read \`.pactile/capabilities.json\` / \`.pactile/capabilities.md\` and keep the
-  readiness state honest: \`pending\`, \`ready\`, or \`failed\`.
-- For \`codebase-retrieval\`, verify \`.codegraph/\` exists (or initialize it)
-  and confirm the MCP path is usable. After the first index, CodeGraph's file
-  watcher auto-syncs later edits; you do not need to re-run full indexing for
-  every code change.
-- If a capability cannot be made ready, record the failure and fallback path in
-  \`verify.md\` before archiving bootstrap.
-- Validation entrypoint: \`pactile capability-smoke --write-status\`
-
----
+    return `
+## Capability readiness (record before Review and Close)
+
+Init selected optional project capabilities for this repo. Treat them as
+\`pending\` until you verify they work in this checkout.
+
+${checklist}
+
+- Read \`.pactile/capabilities.json\` / \`.pactile/capabilities.md\` and keep the
+  readiness state honest: \`pending\`, \`ready\`, or \`failed\`.
+- For \`codebase-retrieval\`, verify \`.codegraph/\` exists (or initialize it)
+  and confirm the MCP path is usable. After the first index, CodeGraph's file
+  watcher auto-syncs later edits; you do not need to re-run full indexing for
+  every code change.
+- If a capability cannot be made ready, record the failure and fallback path in
+  this Task's evidence before independent Review and Close.
+- Validation entrypoint: \`pactile capability-smoke --write-status\`
+
+---
 `;
 }
 function getBootstrapRelatedFiles(projectType, packages) {
@@ -286,145 +469,114 @@ function getBootstrapRelatedFiles(projectType, packages) {
     }
     return [".pactile/spec/backend/", ".pactile/spec/frontend/"];
 }
-function getBootstrapPrdContent(projectType, pythonCmd, selectedCapabilities, packages) {
+function getBootstrapPrdContent(projectType, selectedCapabilities, packages) {
     const checklistItems = getBootstrapChecklistItems(projectType, packages);
     const checklistMarkdown = checklistItems
         .map((item) => `- [ ] ${item}`)
         .join("\n");
-    const header = `# Bootstrap Task: Fill Project Development Guidelines
-
-**You (the AI) are running this task. The developer does not read this file.**
-
-The developer just ran \`pactile init\` on this project for the first time.
-\`.pactile/\` now exists with empty spec scaffolding, and this bootstrap task
-exists under \`.pactile/tasks/\`. When they want to work on it, they should start
-this task from a session that provides Pactile session identity.
-
-**Your job**: help them populate \`.pactile/spec/\` with the team's real
-coding conventions. Every future AI session — this project's
-\`pactile-implement\` and \`pactile-check\` sub-agents — auto-loads spec files
-listed in per-task jsonl manifests. Empty spec = sub-agents write generic
-code. Real spec = sub-agents match the team's actual patterns.
-
-Don't dump instructions. Open with a short greeting, figure out if the repo
-has any existing convention docs (AGENTS.md, .cursorrules, CONTRIBUTING.md, etc.), and drive
-the rest conversationally.
-
----
-
-## Status (update the checkboxes as you complete each item)
-
-${checklistMarkdown}
-
----
-
-${renderCapabilityReadinessSection(selectedCapabilities)}
-
-## Spec files to populate
+    const acceptanceMarkdown = getBootstrapTaskDefinition(projectType, selectedCapabilities, packages)
+        .acceptanceCriteria.map((criterion) => `- [ ] ${criterion.id}: ${criterion.description}`)
+        .join("\n");
+    const header = `# Bootstrap Task: Fill Project Development Guidelines
+
+**Task state: V2 Define. No Run exists, and init does not authorize execution.**
+
+pactile init created this V2 Task as a proposal to document the project's actual conventions. Its kernel.json records Task state; this prd.md is the human-readable plan. Before starting any Run or making project changes, obtain the user's ordinary, explicit approval for that work.\n\n**Deliverable**: useful, evidence-based project guidance in .pactile/spec/. Read the current workflow and the project itself. Do not assume that a named sub-agent, host hook, or automatic prompt injection is installed or active; verify actual host behavior before making such a claim. Contributors can consult relevant spec files directly when working on this project.
+
+Don't dump instructions. Open with a short greeting, figure out if the repo
+has any existing convention docs (AGENTS.md, CONTRIBUTING.md, etc.), and drive
+the rest conversationally.
+
+---
+
+## Status (update the checkboxes as you complete each item)
+
+${checklistMarkdown}
+
+## Acceptance criteria
+
+${acceptanceMarkdown}
+
+---
+
+${renderCapabilityReadinessSection(selectedCapabilities)}
+
+## Spec files to populate
 `;
-    const backendSection = `
-
-### Backend guidelines
-
-| File | What to document |
-|------|------------------|
-| \`.pactile/spec/backend/directory-structure.md\` | Where different file types go (routes, services, utils) |
-| \`.pactile/spec/backend/database-guidelines.md\` | ORM, migrations, query patterns, naming conventions |
-| \`.pactile/spec/backend/error-handling.md\` | How errors are caught, logged, and returned |
-| \`.pactile/spec/backend/logging-guidelines.md\` | Log levels, format, what to log |
-| \`.pactile/spec/backend/quality-guidelines.md\` | Code review standards, testing requirements |
+    const backendSection = `
+
+### Backend guidelines
+
+| File | What to document |
+|------|------------------|
+| \`.pactile/spec/backend/directory-structure.md\` | Where different file types go (routes, services, utils) |
+| \`.pactile/spec/backend/database-guidelines.md\` | ORM, migrations, query patterns, naming conventions |
+| \`.pactile/spec/backend/error-handling.md\` | How errors are caught, logged, and returned |
+| \`.pactile/spec/backend/logging-guidelines.md\` | Log levels, format, what to log |
+| \`.pactile/spec/backend/quality-guidelines.md\` | Code review standards, testing requirements |
 `;
-    const frontendSection = `
-
-### Frontend guidelines
-
-| File | What to document |
-|------|------------------|
-| \`.pactile/spec/frontend/directory-structure.md\` | Component/page/hook organization |
-| \`.pactile/spec/frontend/component-guidelines.md\` | Component patterns, props conventions |
-| \`.pactile/spec/frontend/hook-guidelines.md\` | Custom hook naming, patterns |
-| \`.pactile/spec/frontend/state-management.md\` | State library, patterns, what goes where |
-| \`.pactile/spec/frontend/type-safety.md\` | TypeScript conventions, type organization |
-| \`.pactile/spec/frontend/quality-guidelines.md\` | Linting, testing, accessibility |
+    const frontendSection = `
+
+### Frontend guidelines
+
+| File | What to document |
+|------|------------------|
+| \`.pactile/spec/frontend/directory-structure.md\` | Component/page/hook organization |
+| \`.pactile/spec/frontend/component-guidelines.md\` | Component patterns, props conventions |
+| \`.pactile/spec/frontend/hook-guidelines.md\` | Custom hook naming, patterns |
+| \`.pactile/spec/frontend/state-management.md\` | State library, patterns, what goes where |
+| \`.pactile/spec/frontend/type-safety.md\` | TypeScript conventions, type organization |
+| \`.pactile/spec/frontend/quality-guidelines.md\` | Linting, testing, accessibility |
 `;
-    const footer = `
-
-### Thinking guides (already populated)
-
-\`.pactile/spec/guides/\` contains general thinking guides pre-filled with
-best practices. Customize only if something clearly doesn't fit this project.
-
----
-
-## How to fill the spec
-
-### Step 1: Import from existing convention files first (preferred)
-
-Search the repo for existing convention docs. If any exist, read them and
-extract the relevant rules into the matching \`.pactile/spec/\` files —
-usually much faster than documenting from scratch.
-
-| File / Directory | Notes |
-|------|------|
-| \`AGENTS.md\` | Agent entry / managed instructions |
-| \`.cursorrules\` | Legacy Cursor rules file |
-| \`.cursor/rules/*.mdc\` | Cursor rules directory |
-| \`CONTRIBUTING.md\` | General project conventions |
-| \`.editorconfig\` | Editor formatting rules |
-
-### Step 2: Analyze the codebase for anything not covered by existing docs
-
-Scan real code to discover patterns. Before writing each spec file:
-- Find 2-3 real examples of each pattern in the codebase.
-- Reference real file paths (not hypothetical ones).
-- Document anti-patterns the team clearly avoids.
-
-### Step 3: Document reality, not ideals
-
-**Critical**: write what the code *actually does*, not what it should do.
-Sub-agents match the spec, so aspirational patterns that don't exist in the
-codebase will cause sub-agents to write code that looks out of place.
-
-If the team has known tech debt, document the current state — improvement
-is a separate conversation, not a bootstrap concern.
-
----
-
-## Quick explainer of the runtime (share when they ask "why do we need spec at all")
-
-- Every AI coding task spawns two sub-agents: \`pactile-implement\` (writes
-  code) and \`pactile-check\` (verifies quality).
-- Each task has \`implement.jsonl\` / \`check.jsonl\` manifests listing which
-  spec files to load.
-- The platform hook auto-injects those spec files + the task's \`prd.md\`
-  into every sub-agent prompt, so the sub-agent codes/reviews per team
-  conventions without anyone pasting them manually.
-- Source of truth: \`.pactile/spec/\`. That's why filling it well now pays
-  off forever.
-
----
-
-## Completion
-
-When the developer confirms the checklist items above are done with real
-examples (not placeholders), guide them to run:
-
-\`\`\`bash
-${pythonCmd} ./.pactile/scripts/task.py archive 00-bootstrap-guidelines
-\`\`\`
-
-After archive, every new developer who joins this project will get a
-\`00-join-<slug>\` onboarding task instead of this bootstrap task.
-
----
-
-## Suggested opening line
-
-"Welcome to Pactile! Your init just set me up to help you fill the project
-spec — a one-time setup so every future AI session follows the team's
-conventions instead of writing generic code. Before we start, do you have
-any existing convention docs (AGENTS.md, .cursorrules, CONTRIBUTING.md,
-etc.) I can pull from, or should I scan the codebase from scratch?"
+    const footer = `
+
+### Thinking guides (already populated)
+
+\`.pactile/spec/guides/\` contains general thinking guides pre-filled with
+best practices. Customize only if something clearly doesn't fit this project.
+
+---
+
+## How to fill the spec
+
+### Step 1: Import from existing convention files first (preferred)
+
+Search the repo for existing convention docs. If any exist, read them and
+extract the relevant rules into the matching \`.pactile/spec/\` files —
+usually much faster than documenting from scratch.
+
+| File / Directory | Notes |
+|------|------|
+| \`AGENTS.md\` | Agent entry / managed instructions |
+| \`CONTRIBUTING.md\` | General project conventions |
+| \`.editorconfig\` | Editor formatting rules |
+
+### Step 2: Analyze the codebase for anything not covered by existing docs
+
+Scan real code to discover patterns. Before writing each spec file:
+- Find 2-3 real examples of each pattern in the codebase.
+- Reference real file paths (not hypothetical ones).
+- Document anti-patterns the team clearly avoids.
+
+### Step 3: Document reality, not ideals
+
+**Critical**: write what the code *actually does*, not what it should do.
+Separate verified patterns from open questions so the documentation does not
+present aspirational conventions as current behavior.
+
+If the team has known tech debt, document the current state — improvement
+is a separate conversation, not a bootstrap concern.
+
+---
+
+## How this fits the Task workflow\n\n- A V2 Task Kernel records the definition, hard dependencies, Runs, candidate snapshots, independent Reviews, and Close evidence. .pactile/workflow.md is a human overview; the Kernel is lifecycle authority.\n- This generated Task has no Run. A Run may begin only after the user approves the specific work through the ordinary approval flow.\n- A completed Run produces a candidate that must receive an independent Review bound to that exact candidate. Close uses the latest passing Review and evidence for every acceptance criterion, with documentation delivery evidence for this Task.\n- Scheduler suggestions do not grant approval or bypass Kernel gates. Use the current V2 Task commands and pactile task --help for their arguments.\n\n---\n
+## Completion\n\nWhen the checklist items are complete, record evidence for every acceptance criterion, including references to the documented files and real examples. Ask the user before creating a Run. Then follow the V2 lifecycle: approved Run, candidate-bound independent Review, and Close with matching documentation delivery evidence. Init, a scheduler plan, or this PRD is not execution approval.
+
+---
+
+## Suggested opening line
+
+"Welcome to Pactile! Init created a proposal to document this project's conventions. Do you have existing convention docs (AGENTS.md, CONTRIBUTING.md, or similar) I should compare with the code, or should I begin by inspecting the repository?"
 `;
     let content = header;
     if (packages && packages.length > 0) {
@@ -455,222 +607,193 @@ etc.) I can pull from, or should I scan the codebase from scratch?"
     content += footer;
     return content;
 }
-function getBootstrapTaskJson(developer, projectType, packages) {
-    const today = new Date().toISOString().split("T")[0];
+function getBootstrapTaskDefinition(projectType, selectedCapabilities, packages) {
     const relatedFiles = getBootstrapRelatedFiles(projectType, packages);
-    // Canonical 24-field shape via emptyTaskJson factory.
-    // Checklist items (previously stored as structured `subtasks`) are now
-    // rendered as `- [ ]` items in prd.md; task.json.subtasks is always
-    // string[] (child task dir names) per the canonical schema.
-    return emptyTaskJson({
-        id: BOOTSTRAP_TASK_NAME,
-        name: BOOTSTRAP_TASK_NAME,
-        title: "Bootstrap Guidelines",
-        description: "Fill in project development guidelines for AI agents",
-        status: "in_progress",
-        dev_type: "docs",
-        priority: "P1",
-        creator: developer,
-        assignee: developer,
-        createdAt: today,
-        relatedFiles,
-        notes: `First-time setup task created by pactile init (${projectType} project)`,
-    });
+    const checklistItems = getBootstrapChecklistItems(projectType, packages);
+    const acceptanceCriteria = [
+        {
+            id: "AC-1",
+            description: "Complete the project-specific checklist (" +
+                checklistItems.join("; ") +
+                ") and update the relevant spec files: " +
+                relatedFiles.join(", ") +
+                ".",
+        },
+        {
+            id: "AC-2",
+            description: "For each documented convention, cite at least two real repository examples or source documents; mark unsupported claims as open questions instead of presenting them as facts.",
+        },
+    ];
+    if (selectedCapabilities.length > 0) {
+        acceptanceCriteria.push({
+            id: "AC-3",
+            description: "Record each selected capability as ready, pending, or failed using observable verification evidence; do not report a capability as ready without that evidence.",
+        });
+    }
+    return {
+        taskId: BOOTSTRAP_TASK_NAME,
+        title: "Populate project development guidelines",
+        description: "Document verified project conventions in the Pactile specification files.",
+        deliverable: "Evidence-based project guidance in " +
+            relatedFiles.join(", ") +
+            " with acceptance evidence recorded for this Task.",
+        deliveryLevel: "documentation",
+        acceptanceCriteria,
+        dependencies: [],
+    };
 }
 /**
  * Create bootstrap task for first-time setup
  */
-function createBootstrapTask(cwd, developer, pythonCmd, projectType, selectedCapabilities, packages) {
-    const taskJson = getBootstrapTaskJson(developer, projectType, packages);
-    const prdContent = getBootstrapPrdContent(projectType, pythonCmd, selectedCapabilities, packages);
-    return writeTaskSkeleton(cwd, BOOTSTRAP_TASK_NAME, taskJson, prdContent);
+function createBootstrapTask(cwd, developer, projectType, selectedCapabilities, packages) {
+    const definition = getBootstrapTaskDefinition(projectType, selectedCapabilities, packages);
+    const prdContent = getBootstrapPrdContent(projectType, selectedCapabilities, packages);
+    return writeTaskSkeleton(cwd, BOOTSTRAP_TASK_NAME, definition, "pactile init (" + developer + ")", prdContent);
 }
 // =============================================================================
 // Joiner Onboarding Task Creation
 // =============================================================================
-/**
- * task.json factory for joiner onboarding. Mirrors the bootstrap factory but
- * uses dev_type "docs", higher priority "P1", and the developer-specific task
- * name (so multiple joiners in the same checkout don't collide).
- */
-function getJoinerTaskJson(developer, taskName) {
-    const today = new Date().toISOString().split("T")[0];
-    return emptyTaskJson({
-        id: taskName,
-        name: taskName,
-        title: `Joining: Onboard to this Pactile project (${developer})`,
-        description: "Onboard a new developer to an existing Pactile project: learn the workflow, conventions, and find assigned work",
-        status: "in_progress",
-        dev_type: "docs",
-        priority: "P1",
-        creator: developer,
-        assignee: developer,
-        createdAt: today,
-        notes: "Generated by pactile init for a new developer joining an existing Pactile project",
-    });
+/** Create the V2 documentation Task used for a new project joiner. */
+function getJoinerTaskDefinition(developer, taskId, taskName, selectedCapabilities) {
+    const acceptanceCriteria = [
+        {
+            id: "AC-1",
+            description: "Create onboarding-notes.md in the Task directory with references to this project's actual workflow and specification files, and explain that the Kernel controls lifecycle state.",
+        },
+        {
+            id: "AC-2",
+            description: "Record the active V2 Task IDs found or explicitly state that none are listed; do not infer V2 assignment from legacy task fields.",
+        },
+    ];
+    if (selectedCapabilities.length > 0) {
+        acceptanceCriteria.push({
+            id: "AC-3",
+            description: "Record each selected capability as ready, pending, or failed with observable verification evidence, or state that verification was not performed.",
+        });
+    }
+    return {
+        taskId,
+        title: "Onboard developer to this Pactile project: " + developer,
+        description: "Prepare a concise onboarding note based on the actual project workflow, conventions, and visible V2 Tasks.",
+        deliverable: "A project-specific onboarding note at .pactile/tasks/" +
+            taskName +
+            "/onboarding-notes.md with evidence for each acceptance criterion.",
+        deliveryLevel: "documentation",
+        acceptanceCriteria,
+        dependencies: [],
+    };
 }
 /**
  * PRD content for joiner onboarding. Kept concise (~80 lines) — deeper
  * guidance lives in skills and docs.
  */
-function getJoinerPrdContent(developer, pythonCmd, selectedCapabilities) {
-    const slug = slugifyDeveloperName(developer);
+function getJoinerPrdContent(developer, taskName, taskId, selectedCapabilities) {
     const selectedCapabilityChecklist = selectedCapabilities
         .map((id) => {
         const capability = getProjectCapability(id);
-        return `- \`${capability.id}\` — re-check readiness in this clone before claiming it is available.`;
+        return ("- " +
+            capability.id +
+            " — re-check readiness in this clone before claiming it is available.");
     })
         .join("\n");
-    let capabilitySection = "";
-    if (selectedCapabilities.length > 0) {
-        capabilitySection = `
-### 5. Re-verify selected project capabilities
-
-This repo has capability selections recorded in \`.pactile/capabilities.json\`.
-Before they rely on MCP-backed behavior, remind them to check the selected set:
-
-${selectedCapabilityChecklist}
-
-- If a capability is not \`ready\`, have them re-run the local verification path
-  instead of assuming the previous machine's setup carries over.
-
----
-`;
-    }
-    return `# Joiner Onboarding Task
-
-**You (the AI) are running this task. The developer does not read this file.**
-
-\`${developer}\` just ran \`pactile init\` on a fresh clone, saw "Developer
-initialized", and will now start asking you questions in chat. This joiner task
-exists under \`.pactile/tasks/\`; when they want to work on it, they should
-select it from a session that provides Pactile session identity.
-
-Your job is to orient them to Pactile. Don't dump all of this at them — open
-with a short greeting, ask where they want to start, and fill in the rest as
-they engage.
-
----
-
-## Topics to cover (adapt order to their questions)
-
-### 1. What Pactile is + the workflow
-
-Pactile is a governed capability workspace for Cursor and Codex that keeps AI
-agents consistent with project-specific conventions instead of writing generic
-code every session.
-
-- **Human lifecycle**: Open → Define → Approve → Execute → Verify →
-  (Integrate? when parent-child) → Close. Kernel writes that state.
-  \`.pactile/workflow.md\` is a human overview, **not runtime SSOT**.
-- **Task files** live under \`.pactile/tasks/\`. \`status\` is a projection, not
-  the only truth.
-- **User slash (Native Cursor)**:
-  - \`/pactile-continue\` — resume only when this live session already has a
-    selected task
-  - \`/pactile-finish-work\` — wrap up a finished task
-  - \`/pactile-handoff\` — session handoff to a temp path (not the task's
-    \`handoff.md\`)
-  SessionStart covers entry. \`/pactile-start\` is not installed as a slash on
-  agent-capable Cursor. Official \`/goal\` is not a Pactile Task.
-
-### 2. Runtime mechanics (explain when they ask "how does it know what to do")
-
-- **SessionStart hook** injects identity, git status, selected task, Task
-  Dashboard, and a compiled session pack when Event Bridge subscribers
-  produce one. It must not dump \`workflow.md\` Phase Index as the runtime
-  program.
-- **\`/pactile-continue\`** loads Kernel / Dashboard (or the compiled pack if
-  already in context), reads \`prd.md\` + recent activity, and routes by
-  Kernel human phase. Do **not** treat \`get_context.py --mode phase\` (Phase
-  Index) as runtime SSOT. Internal skills (brainstorm, check, …) are not
-  user slash commands.
-- **Workers**: if this Cursor Task API has no \`pactile-implement\` /
-  \`pactile-check\` enum, dispatch as \`generalPurpose\`. Never label that run
-  \`true-independent\`. When a check worker is available, it follows
-  \`check.jsonl\` — reviews against specs, auto-fixes issues, runs
-  lint/typecheck.
-
-File layout (mention when they ask "where does what live"):
-- \`.pactile/.runtime/sessions/<session>.json\` — live-session selected-task state, gitignored
-- \`.pactile/tasks/<task>/{implement,check}.jsonl\` — per-task context manifests
-- \`.pactile/spec/\` — project-wide conventions (source of truth)
-- \`.pactile/workspace/${developer}/journal-*.md\` — their session log,
-  rotated at ~2000 lines
-
-### 3. This project's actual conventions
-
-- Summarize \`.pactile/spec/\` for them — what coding conventions this
-  specific team enforces.
-- Point at the last 5 entries in \`.pactile/tasks/archive/\` as a rhythm
-  example of how people actually work here. **If archive is empty** (the
-  project just started), skip this — don't invent examples.
-- Not your job in this onboarding to teach them the business code itself —
-  the README and their teammates handle that.
-
-### 4. Their assigned work
-
-- Check if \`.pactile/workspace/${developer}/\` already exists — if yes, it's
-  their journal from another machine and worth mentioning.
-- Run \`${pythonCmd} ./.pactile/scripts/task.py list --assignee ${developer}\` to
-  show tasks assigned to them. (Quote the name if it contains spaces.)
-- Remind them that the "My Tasks" section appears in the SessionStart context
-  on every new session.
-
----
-
-${capabilitySection}
-
-## Optional: walk through a small task end-to-end
-
-If they want to practice before touching real work, offer to pick a tiny
-P3 task or a typo fix and run the full cycle together: \`/pactile-continue\`
-→ implement in Agent → \`/pactile-finish-work\`.
-
----
-
-## Completion
-
-When they feel oriented (or after you've covered the four topics with
-reasonable back-and-forth), guide them to run:
-
-\`\`\`bash
-${pythonCmd} ./.pactile/scripts/task.py archive 00-join-${slug}
-\`\`\`
-
----
-
-## Suggested opening line
-
-"Welcome! Your \`pactile init\` set me up to onboard you to this project. I
-can walk you through the workflow, show you the runtime mechanics under the
-hood, summarize the team's spec, or jump to what you're already curious about
-— which would you prefer?"
-`;
+    const capabilitySection = selectedCapabilities.length > 0
+        ? [
+            "### Selected project capabilities",
+            "",
+            "Re-check each selected capability in this clone before relying on it:",
+            "",
+            selectedCapabilityChecklist,
+            "",
+            "If verification is incomplete, record it as pending or failed with the fallback path.",
+        ].join("\n")
+        : "";
+    const acceptanceCriteriaMarkdown = getJoinerTaskDefinition(developer, taskId, taskName, selectedCapabilities)
+        .acceptanceCriteria.map((criterion) => "- [ ] " + criterion.id + ": " + criterion.description)
+        .join("\n");
+    return [
+        "# Joiner Onboarding Task",
+        "",
+        "Task ID: " +
+            taskId +
+            ". State: V2 Define. No Run exists, and init does not authorize execution.",
+        "",
+        "pactile init created this V2 Task for " +
+            developer +
+            " as an onboarding proposal. The Kernel in .pactile/tasks/" +
+            taskName +
+            "/kernel.json records its definition and lifecycle. This PRD is the human-readable plan.",
+        "Before starting a Run or changing project files, obtain the user's ordinary, explicit approval for that work.",
+        "",
+        "Your deliverable is a concise onboarding note at .pactile/tasks/" +
+            taskName +
+            "/onboarding-notes.md. Use project evidence, and mark unavailable information as unknown rather than guessing.",
+        "",
+        "## Onboarding topics",
+        "",
+        "### 1. Current Task workflow",
+        "",
+        "- Read .pactile/workflow.md as a human overview. The V2 Task Kernel is lifecycle authority.",
+        "- Explain the Task definition, hard dependencies, and why a Run needs ordinary user approval.",
+        "- Explain that a Task can have multiple Runs and that an independent Review binds to the exact candidate from one Run.",
+        "- Explain that Close uses the latest passing Review, evidence for every acceptance criterion, and the delivery evidence level in the Task definition.",
+        "- Use pactile task --help for the current command arguments. Do not assume a host spawned a named agent or ran a hook without an observable receipt.",
+        "",
+        "### 2. This project's actual conventions",
+        "",
+        "- Read .pactile/spec/ and cite the relevant files in onboarding-notes.md.",
+        "- Compare the written guidance with real repository files; mark unresolved questions explicitly.",
+        "- Do not treat old archive directories or generated phase hints as V2 lifecycle authority.",
+        "",
+        "### 3. Visible V2 Tasks and next steps",
+        "",
+        "- Run pactile task schedule list to inspect visible V2 scheduling candidates. Record their Task IDs, or state that none were listed.",
+        "- Ask the user which approved work they want to pursue. The V2 Task definition has no assignee field, so do not infer assignment from legacy task.json data.",
+        "- If the user wants a practice task, agree on its definition and acceptance criteria first, then follow the ordinary approval, Run, independent Review, and Close gates.",
+        "",
+        capabilitySection,
+        "",
+        "## Acceptance criteria",
+        "",
+        acceptanceCriteriaMarkdown,
+        "",
+        "## Acceptance evidence",
+        "",
+        "In onboarding-notes.md include links or repository-relative paths to the workflow and spec files reviewed, the V2 Task IDs found (or none), and capability verification status when applicable.",
+        "",
+        "Before completion, check every acceptance criterion in the Task definition. Ask the user before any Run, record a candidate-bound independent Review, then Close with documentation delivery evidence that points to onboarding-notes.md. Do not move the task directory as a substitute for Close.",
+        "",
+        "## Suggested opening",
+        "",
+        "Welcome, " +
+            developer +
+            ". I can start by explaining the current Task workflow, reviewing the project conventions, or checking which V2 Tasks are visible. Which is most useful?",
+    ].join("\n");
 }
 /**
  * Create joiner onboarding task for a new developer on an existing Pactile
  * project. Task name is slugified to be filesystem-safe for arbitrary
  * developer names (spaces, Unicode, punctuation).
  */
-function createJoinerOnboardingTask(cwd, developer, pythonCmd) {
+function createJoinerOnboardingTask(cwd, developer) {
     const slug = slugifyDeveloperName(developer);
     const taskName = `00-join-${slug}`;
-    const taskJson = getJoinerTaskJson(developer, taskName);
-    const prdContent = getJoinerPrdContent(developer, pythonCmd, loadProjectCapabilities(cwd));
-    return writeTaskSkeleton(cwd, taskName, taskJson, prdContent);
+    const taskId = taskKernelIdForDirectoryName(taskName);
+    const selectedCapabilities = loadProjectCapabilities(cwd);
+    const definition = getJoinerTaskDefinition(developer, taskId, taskName, selectedCapabilities);
+    const prdContent = getJoinerPrdContent(developer, taskName, taskId, selectedCapabilities);
+    return writeTaskSkeleton(cwd, taskName, definition, `pactile init (${developer})`, prdContent);
 }
 /**
  * Handle re-init when .pactile/ already exists.
  * Returns true if handled (caller should return), false if user chose full re-init.
  */
-async function handleReinit(cwd, options, developerName, pythonCmd) {
+async function handleReinit(cwd, options, developerName) {
     const TOOLS = getPactileInitToolChoices();
     const installState = new InstallStateStore(cwd).read();
     const configuredPlatforms = new Set((installState?.state.installedAdapters ?? [])
         .filter((adapter) => adapter.status === "active")
         .map((adapter) => adapter.id.replace(/^adapter\./, ""))
-        .filter((platform) => platform === "cursor" || platform === "codex"));
+        .filter((platform) => platform === "codex"));
     const configuredNames = [...configuredPlatforms]
         .map((id) => TOOLS.find((choice) => choice.platformId === id)?.name ?? id)
         .join(", ");
@@ -683,7 +806,7 @@ async function handleReinit(cwd, options, developerName, pythonCmd) {
     if (!doAddPlatforms && !doAddDeveloper) {
         if (options.yes) {
             console.log(chalk.gray(`Already initialized with: ${configuredNames}`));
-            console.log(chalk.gray("Use platform flags (e.g., --cursor) or -u <name> to add platforms/developer."));
+            console.log(chalk.gray("Use --codex or -u <name> to add a platform/developer."));
             return true;
         }
         console.log(chalk.gray(`\n   Already initialized with: ${configuredNames}\n`));
@@ -769,26 +892,29 @@ async function handleReinit(cwd, options, developerName, pythonCmd) {
             }
         }
         // Capture pre-init state: if .developer did not exist before we ran
-        // init_developer.py, this checkout had no identity → treat as a new
+        // the Node identity writer, this checkout had no identity → treat as a new
         // joiner onboarding onto an existing Pactile project.
         const hadDeveloperFileBefore = fs.existsSync(path.join(cwd, DIR_NAMES.WORKFLOW, FILE_NAMES.DEVELOPER));
-        try {
-            const scriptPath = path.join(cwd, PATHS.SCRIPTS, "init_developer.py");
-            execSync(`${pythonCmd} "${scriptPath}" "${devName}"`, {
-                cwd,
-                stdio: "pipe",
-            });
-            console.log(chalk.green(`✓ Developer "${devName}" initialized`));
+        const joinerTaskName = `00-join-${slugifyDeveloperName(devName)}`;
+        const joinerIntentReady = hadDeveloperFileBefore ||
+            ensureInitTaskMarker(cwd, joinerTaskName, devName);
+        if (!joinerIntentReady) {
+            console.warn(chalk.yellow("⚠ Could not record joiner recovery intent; developer identity was not initialized"));
         }
-        catch {
-            console.log(chalk.yellow("⚠ Could not initialize developer. Run manually:"));
-            console.log(chalk.gray(`  ${pythonCmd} .pactile/scripts/init_developer.py ${devName}`));
+        if (joinerIntentReady) {
+            try {
+                initializeDeveloper(cwd, devName);
+                console.log(chalk.green(`✓ Developer "${devName}" initialized`));
+            }
+            catch (err) {
+                console.log(chalk.yellow(`⚠ Could not initialize developer: ${err instanceof Error ? err.message : String(err)}`));
+            }
         }
         // Create joiner onboarding task for fresh checkouts (no prior .developer).
         // Runs outside the init_developer try/catch so failures surface as warnings.
-        if (!hadDeveloperFileBefore) {
+        if (!hadDeveloperFileBefore && joinerIntentReady) {
             try {
-                if (!createJoinerOnboardingTask(cwd, devName, pythonCmd)) {
+                if (!createJoinerOnboardingTask(cwd, devName)) {
                     console.warn(chalk.yellow("⚠ Failed to create joiner onboarding task"));
                 }
             }
@@ -800,19 +926,7 @@ async function handleReinit(cwd, options, developerName, pythonCmd) {
     return true;
 }
 function getPactileInitToolChoices() {
-    return [
-        ...getInitToolChoices().map((choice) => ({
-            ...choice,
-            key: choice.key,
-            platformId: choice.platformId,
-        })),
-        {
-            key: "codex",
-            name: "Codex (ChatGPT desktop app)",
-            defaultChecked: true,
-            platformId: "codex",
-        },
-    ];
+    return getInitToolChoices();
 }
 /**
  * Write monorepo package configuration to config.yaml (non-destructive patch).
@@ -897,12 +1011,7 @@ export async function init(options) {
     // Generate ASCII art banner dynamically using FIGlet "Rebel" font
     const banner = figlet.textSync("Pactile", { font: "Rebel" });
     console.log(chalk.cyan(`\n${banner.trimEnd()}`));
-    console.log(chalk.gray("\n   Cross-platform AI workflow framework for Cursor & Codex\n"));
-    // Set up proxy before any network calls
-    const proxyUrl = setupProxy();
-    if (proxyUrl) {
-        console.log(chalk.gray(`   Using proxy: ${maskProxyUrl(proxyUrl)}\n`));
-    }
+    console.log(chalk.gray("\n   Governed AI workflow for Codex\n"));
     // Set write mode based on options
     let writeMode = "ask";
     if (options.force) {
@@ -937,10 +1046,53 @@ export async function init(options) {
             }
         }
     }
+    // A joiner intent is durable before identity is written. Resolve any
+    // existing identity before dispatch so an unrelated request or marker cannot
+    // publish a Task under a second developer name.
+    let persistedDeveloper = null;
+    try {
+        persistedDeveloper = readDeveloper(cwd);
+    }
+    catch {
+        // Keep init best-effort when a user-owned identity file is unreadable.
+    }
+    const pendingJoinerMarkers = readPendingJoinerMarkers(cwd);
+    const validPendingJoinerMarkers = pendingJoinerMarkers.filter((marker) => marker.valid);
+    const hasPersistedDeveloperFile = pathExists(path.join(cwd, PATHS.DEVELOPER_FILE));
+    let requestedDeveloper = null;
+    const trimmedDeveloperName = developerName?.trim();
+    if (trimmedDeveloperName)
+        requestedDeveloper = trimmedDeveloperName;
+    const markerConflictsWithIdentity = (marker, identity) => marker.developerName !== null
+        ? marker.developerName !== identity
+        : marker.taskName !== `00-join-${slugifyDeveloperName(identity)}`;
+    const conflictsWithPersistedDeveloper = persistedDeveloper !== null &&
+        ((requestedDeveloper !== null &&
+            requestedDeveloper !== persistedDeveloper) ||
+            validPendingJoinerMarkers.some((marker) => markerConflictsWithIdentity(marker, persistedDeveloper)));
+    const conflictingRequestAndMarker = requestedDeveloper !== null &&
+        validPendingJoinerMarkers.some((marker) => markerConflictsWithIdentity(marker, requestedDeveloper));
+    const cannotValidatePersistedDeveloper = hasPersistedDeveloperFile &&
+        persistedDeveloper === null &&
+        (requestedDeveloper !== null || validPendingJoinerMarkers.length > 0);
+    if (conflictsWithPersistedDeveloper ||
+        conflictingRequestAndMarker ||
+        cannotValidatePersistedDeveloper) {
+        console.warn(chalk.yellow("⚠ Init stopped: the requested identity, pending joiner marker, and existing .developer identity cannot be reconciled. Preserve existing files and resolve the identity before retrying."));
+        return;
+    }
+    if (!options.user) {
+        if (persistedDeveloper &&
+            hasInitTaskMarker(cwd, `00-join-${slugifyDeveloperName(persistedDeveloper)}`)) {
+            developerName = persistedDeveloper;
+        }
+        else if (!persistedDeveloper) {
+            developerName = readPendingJoinerDeveloperName(cwd) ?? developerName;
+        }
+    }
     if (developerName) {
         console.log(chalk.blue("👤 Developer:"), chalk.gray(developerName));
     }
-    const { command: pythonCmd } = resolveSupportedPython();
     // ==========================================================================
     // Re-init fast path: skip full flow when .pactile/ already exists.
     // ==========================================================================
@@ -949,13 +1101,19 @@ export async function init(options) {
     // to the full flow so the main-dispatch tasksEmpty fallback fires —
     // handleReinit's joiner branch would otherwise mis-route the recovery.
     const tasksDirEarly = path.join(cwd, PATHS.TASKS);
-    const tasksEmptyEarly = !fs.existsSync(tasksDirEarly) || fs.readdirSync(tasksDirEarly).length === 0;
+    const pendingBootstrap = hasInitTaskMarker(cwd, BOOTSTRAP_TASK_NAME);
+    const pendingJoiner = developerName
+        ? hasInitTaskMarker(cwd, `00-join-${slugifyDeveloperName(developerName)}`)
+        : false;
+    const tasksEmptyEarly = !fs.existsSync(tasksDirEarly) || fs.readdirSync(tasksDirEarly).filter((entry) => entry !== ".creating" && !entry.startsWith(".pending-")).length === 0;
     if (!isFirstInit &&
         !importingCstl &&
         !options.force &&
         !options.skipExisting &&
-        !tasksEmptyEarly) {
-        const reinitDone = await handleReinit(cwd, options, developerName, pythonCmd);
+        !tasksEmptyEarly &&
+        !pendingBootstrap &&
+        !pendingJoiner) {
+        const reinitDone = await handleReinit(cwd, options, developerName);
         if (reinitDone)
             return;
         // reinitDone === false means user chose "full re-initialize" → fall through
@@ -1132,7 +1290,7 @@ export async function init(options) {
         tools = explicitTools;
     }
     else if (options.yes) {
-        // No explicit tools + -y: default to Cursor and Codex
+        // No explicit tools + -y: use the active host default.
         tools = TOOLS.filter((t) => t.defaultChecked).map((t) => t.key);
     }
     else {
@@ -1595,17 +1753,43 @@ export async function init(options) {
         // migration backup or prompt for a legacy transition that never existed.
         writeWaveCConfirmed(cwd);
     }
-    // Initialize developer identity (silent - no output)
+    let shouldCreateBootstrap = false;
+    let shouldCreateJoiner = false;
     if (developerName) {
+        const tasksDir = path.join(cwd, PATHS.TASKS);
+        const tasksEmpty = !fs.existsSync(tasksDir) ||
+            fs
+                .readdirSync(tasksDir)
+                .filter((entry) => entry !== ".creating" && !entry.startsWith(".pending-"))
+                .length === 0;
+        shouldCreateBootstrap =
+            (isFirstInit && !importingCstl) ||
+                pendingBootstrap ||
+                (tasksEmpty && !pendingJoiner);
+        shouldCreateJoiner =
+            !shouldCreateBootstrap &&
+                (!hadDeveloperFileAtStart || pendingJoiner);
+    }
+    const joinerTaskName = developerName
+        ? `00-join-${slugifyDeveloperName(developerName)}`
+        : null;
+    const joinerIntentReady = !developerName ||
+        !shouldCreateJoiner ||
+        (joinerTaskName !== null &&
+            ensureInitTaskMarker(cwd, joinerTaskName, developerName ?? undefined));
+    if (shouldCreateJoiner && !joinerIntentReady) {
+        console.warn(chalk.yellow("⚠ Could not record joiner recovery intent; developer identity was not initialized"));
+    }
+    // Initialize developer identity with Node (silent - no output). For a fresh
+    // joiner, the recovery intent must be durable before this write so a process
+    // interruption cannot leave identity without its onboarding Task.
+    if (developerName && joinerIntentReady) {
         try {
-            const scriptPath = path.join(cwd, PATHS.SCRIPTS, "init_developer.py");
-            execSync(`${pythonCmd} "${scriptPath}" "${developerName}"`, {
-                cwd,
-                stdio: "pipe", // Silent
-            });
+            if (!readDeveloper(cwd))
+                initializeDeveloper(cwd, developerName);
         }
         catch {
-            // Silent failure - user can run init_developer.py manually
+            // Preserve init's best-effort identity creation boundary.
         }
         // Three-branch dispatch using flags captured at init() start (before
         // createWorkflowStructure/init_developer ran, so they reflect the disk
@@ -1622,17 +1806,18 @@ export async function init(options) {
         // Runs OUTSIDE the init_developer try/catch (which uses stdio: "pipe")
         // so joiner failures surface as warnings instead of being silently
         // swallowed.
-        const tasksDir = path.join(cwd, PATHS.TASKS);
-        const tasksEmpty = !fs.existsSync(tasksDir) || fs.readdirSync(tasksDir).length === 0;
-        if ((isFirstInit && !importingCstl) || tasksEmpty) {
-            const bootstrapCreated = createBootstrapTask(cwd, developerName, pythonCmd, projectType, selectedCapabilities, monorepoPackages);
+        if (shouldCreateBootstrap) {
+            const bootstrapCreated = createBootstrapTask(cwd, developerName, projectType, selectedCapabilities, monorepoPackages);
             if (bootstrapCreated) {
                 console.log(chalk.gray(`Next: complete ${BOOTSTRAP_TASK_NAME} to verify selected capabilities and fill the project spec.`));
             }
+            else {
+                console.warn(chalk.yellow(`⚠ Failed to create ${BOOTSTRAP_TASK_NAME}; inspect .pactile/tasks/ and retry pactile init.`));
+            }
         }
-        else if (!hadDeveloperFileAtStart) {
+        else if (shouldCreateJoiner) {
             try {
-                if (!createJoinerOnboardingTask(cwd, developerName, pythonCmd)) {
+                if (!createJoinerOnboardingTask(cwd, developerName)) {
                     console.warn(chalk.yellow("⚠ Failed to create joiner onboarding task"));
                 }
             }