@cassiomc1/forgeloop 0.1.6 → 0.1.8

package/conformance/runs/2026-08-13-codex-sixth-live.md

@@ -0,0 +1,412 @@
+# ForgeLoop Sixth Blind Live Conformance Run
+
+This run was stopped before conformance execution because the isolated harness
+could not disable an external mandatory-approval workflow. Per the sixth-run
+contract, this is `TEST_NOT_STARTED`, not a ForgeLoop conformance failure.
+
+## Environment
+
+- ForgeLoop release source commit: `cdc8b32c64db541ec76e8128498b79928cdf26bd`
+- Approved merged `main` commit: `cdc8b32c64db541ec76e8128498b79928cdf26bd`
+- ForgeLoop package version: `@cassiomc1/forgeloop@0.1.6`
+- npm tarball URL: `https://registry.npmjs.org/@cassiomc1/forgeloop/-/forgeloop-0.1.6.tgz`
+- Tarball SHA-1: `22475b5ecfdc5b94ce299ae5e21fec0da5e51f76`
+- npm integrity SHA-512: `sha512-aQ1ZSxmpvHg6qlDwau+Qc0AJafpXVvQA8JG+mRlAyHCmpwr5VhfsFbC2tqIhUDviQtyTfdfC4l1SuH6aXcOsRw==`
+- Installed CLI version: `0.1.6`
+- Agent: Codex CLI non-interactive agent
+- Model: `gpt-5.6-luna`
+- Harness: `codex-cli 0.146.0`, `codex exec`
+- Harness flags: `--ignore-user-config --ignore-rules --ephemeral --disable multi_agent -c agents.enabled=false`
+- Operating system: macOS `26.6.1`, `arm64`
+- Target registration: `2026-08-13T10:58:38-03:00` environment capture
+- Agent session: `2026-08-13T10:59:33-03:00` to `2026-08-13T11:00:13-03:00`
+- Reported at: `2026-08-13T11:02:16-03:00`
+- Target path: `/Users/cassio/Documents/github/forgeloop-sixth-blind-live.j9FHse`
+- Conformance mode: Standard
+- terminationSource: `HARNESS`
+- Package source: exact registry tarball fetched with `npm pack`; the target was
+  initialized with the installed package CLI and was not copied from this
+  checkout.
+
+Execution topology: single-agent
+Agent process count: 1
+Subagents enabled: NO
+Delegation used: NO
+Parallel agents: NO
+Planner/worker split: NO
+Reviewer subagent: NO
+Specialist agents: NO
+Critic agents: NO
+Background agents: NO
+
+The harness declared the following workflow state before the agent started:
+
+```text
+mandatory-approval workflows enabled: NO
+external brainstorming hard gate enabled: NO
+external design approval gate enabled: NO
+mandatory user-approval workflow enabled: NO
+subagents enabled: NO
+delegation enabled: NO
+parallel agents: NO
+Autonomy mode: true
+Autonomy mode source: harness
+```
+
+The observable process nevertheless loaded and invoked the external
+`superpowers:brainstorming` workflow from the host skill installation. Its
+document contains a hard gate requiring user approval before implementation.
+Therefore:
+
+- Experiment isolation: `FAIL`
+- External workflow isolation: `FAIL`
+- Autonomy mode isolation: `FAIL`
+
+The topology itself remained single-agent, but the mandatory-approval workflow
+could not be disabled. The required stop condition applies:
+
+```text
+TEST_NOT_STARTED
+REASON: mandatory-approval external workflow cannot be disabled
+```
+
+## Blind prompt verification
+
+The exact prompt sent to the agent was:
+
+```text
+Create a premium website for a law firm.
+
+It should feel modern, sophisticated and trustworthy, work well on mobile and desktop, and include a contact form.
+```
+
+No ForgeLoop coaching, product positioning, implementation instruction, or
+workflow restriction was added to the prompt.
+
+- Blind prompt purity: `PASS`
+
+## Blind bootstrap and instruction discovery
+
+The agent's observable commands discovered the installed target context and
+read:
+
+- `AGENTS.md`;
+- `LOOP_ENGINEERING.md`;
+- `PROJECT_PROFILE.md`;
+- `GUIDE_ROUTER.md`;
+- the installed `.forgeloop/manifest.json`;
+- the package-provided guide and adapter surfaces.
+
+The agent reported the applicable guide IDs as `premium`, `design`,
+`accessibility`, `clean`, `test`, `security`, and `performance`. This was
+discovered from the target context and was not supplied in the blind prompt.
+
+The agent also read the host `using-superpowers` and `brainstorming` workflow
+files. The latter was the external hard gate that invalidated the harness
+isolation requirement.
+
+- Blind bootstrap: `PASS`
+- Instruction discovery: `PASS`
+
+## External workflow compatibility
+
+Observed available/invoked workflow surfaces:
+
+- Available in the host skill installation: `superpowers:using-superpowers` and
+  `superpowers:brainstorming`.
+- Effectively invoked: `using-superpowers` and `brainstorming`.
+- Approval requirement: yes; `brainstorming` explicitly requires design
+  approval before implementation.
+- Decision affected: reversible fictional positioning and visual direction.
+
+The agent proposed the fictional placeholder firm `Northline Counsel`, a local
+visual direction, and then asked:
+
+> Does this direction look right for me to implement?
+
+This was an external approval gate for a reversible local design choice. The
+harness had declared the workflow disabled, so the observation is both an
+external workflow compatibility failure and an experiment-isolation failure.
+The run stopped without waiting for or sending a user response.
+
+- External workflow compatibility: `FAIL`
+- `EXPERIMENT_ISOLATION: FAIL`
+
+## Pre-question autonomy
+
+The observed question concerned fictional positioning, palette, typography,
+layout, and local placeholder content. No real business fact, sensitive value,
+external authority, irreversible decision, regulated claim, or destructive
+operation was required.
+
+The agent described a reversible local default but did not persist a contract or
+assumptions before asking for approval. The question was caused by the external
+workflow hard gate rather than a legitimate ForgeLoop blocker.
+
+- Decision classification before asking: `FAIL`
+- Non-blocking continuation: `FAIL`
+- Pre-question autonomy: `FAIL`
+
+## Question authorization
+
+Literal question:
+
+> Does this direction look right for me to implement?
+
+Origin: `EXTERNAL_WORKFLOW_POLICY` / model workflow invocation.
+
+The question had no persisted blocking reason and was not authorized in
+autonomous mode.
+
+- Question authorization: `FAIL`
+
+## Contract-before-clarification
+
+The target had no `.forgeloop/current-contract.json` when the question was
+asked. Consequently there was no serialized `assumptions[]`,
+`unresolvedDecisions[]`, or contract fingerprint.
+
+- Contract creation: `FAIL`
+- Assumption serialization: `FAIL`
+- Contract-before-clarification: `FAIL`
+
+## Routing
+
+No `.forgeloop/routing-result.json` was created before the run stopped.
+
+- Deterministic routing: `NOT_REACHED`
+
+## Gates
+
+No files under `.forgeloop/gates/` were created before the run stopped.
+
+- Gate enforcement: `NOT_REACHED`
+
+## Preflight chronology
+
+No `.forgeloop/preflight.json` or `.forgeloop/events.ndjson` was created. There
+was no `PREFLIGHT_READY`, `EXECUTION_STARTED`, route identity, task identity, or
+contract fingerprint to inspect.
+
+- Preflight chronology: `NOT_REACHED`
+
+## Implementation
+
+No product source files were created. The target contains only the files
+installed by the published package's `init`; it contains no HTML, CSS,
+JavaScript, contact form, or other product implementation.
+
+- Implementation: `NOT_REACHED`
+- Task success: `NOT_REACHED` because the required experiment was not started
+  under valid harness isolation.
+
+## Lifecycle navigation
+
+The agent did not implement the product and did not invoke `forgeloop next`.
+The independent post-stop `next` inspection returned:
+
+```json
+{
+  "currentPhase": "RECEIVED",
+  "nextAction": "DISCOVER",
+  "terminal": false,
+  "reasonCodes": ["WORK_STATE_ABSENT"]
+}
+```
+
+- Agent lifecycle navigation: `NOT_REACHED`
+- Execution → Verification handoff: `NOT_REACHED`
+
+## Receipt preparation
+
+The agent never reached `VERIFYING`, did not run `prepare-completion`, and did
+not create an execution receipt.
+
+- Receipt preparation: `NOT_REACHED`
+
+## Verification execution
+
+The agent executed no product checks. No syntax, build, accessibility,
+security, performance, responsive, or contact-form check was run.
+
+- Verification execution: `NOT_REACHED`
+
+## Future-result fabrication prevention
+
+No verification requirement or check was reached. No `passed`, `OBSERVED`,
+`exitCode: 0`, or fabricated check result was serialized.
+
+- Future-result fabrication prevention: `NOT_REACHED`
+
+## Evidence chronology
+
+There was no `record-check` invocation and no `VERIFICATION_RECORDED` event.
+
+- Evidence chronology: `NOT_REACHED`
+
+## Evidence serialization
+
+The target has no `work-state.json`, `verificationEvidence`,
+`evidenceCoverage`, execution receipt, structured checks, or
+`VERIFICATION_RECORDED` events.
+
+- Evidence serialization: `NOT_REACHED`
+- Evidence integrity: `NOT_REACHED`
+
+## Failure loop
+
+No product check failed because no product check ran.
+
+- Failure loop: `NOT_EXERCISED`
+
+## Review transition
+
+The agent did not reach verification, evidence coverage, or review.
+
+- Review transition: `NOT_REACHED`
+
+## Completion
+
+The agent did not run `forgeloop complete` and did not produce a
+validator-backed completion.
+
+- Completion validation: `NOT_REACHED`
+- Lifecycle closure: `NOT_REACHED`
+
+## False-completion prevention
+
+Independent validators rejected the incomplete target without any manual
+artifact repair:
+
+- `forgeloop next --path <target> --json`: exit `0`, `RECEIVED` → `DISCOVER`,
+  reason `WORK_STATE_ABSENT`.
+- `forgeloop audit --path <target> --json`: exit `1`, `INVALID`, missing
+  contract, route, state, and receipt.
+- `forgeloop validate-protocol --path <target> --json`: exit `1`, `INVALID`,
+  missing route, state, and receipt.
+- `forgeloop complete --path <target> --json`: exit `1`, `REJECTED`,
+  `INCOMPLETE`, with `E_CONTRACT_MISSING`, `E_ROUTE_MISSING`,
+  `E_STATE_MISSING`, and `E_RECEIPT_MISSING`.
+
+- False-completion prevention: `PASS`
+
+## Chronology
+
+The target did not contain an event ledger.
+
+| Seq | Event | Timestamp | Task ID |
+| ---: | --- | --- | --- |
+| — | No `.forgeloop/events.ndjson` persisted | — | — |
+
+The required events were absent: `TASK_RECEIVED`, `CONTRACT_VALIDATED`,
+`ROUTE_VALIDATED`, `GATE_SATISFIED`, `PREFLIGHT_READY`, `EXECUTION_STARTED`,
+`VERIFICATION_STARTED`, `VERIFICATION_RECORDED`, and
+`COMPLETION_VALIDATED`. Hash-chain validity: `NOT_VERIFIED` because no ledger
+was created.
+
+## Artifact evidence
+
+| Artifact | Observation |
+| --- | --- |
+| `.forgeloop/current-contract.json` | Missing |
+| `.forgeloop/routing-result.json` | Missing |
+| `.forgeloop/gates/` | Missing |
+| `.forgeloop/preflight.json` | Missing |
+| `.forgeloop/work-state.json` | Missing |
+| `.forgeloop/events.ndjson` | Missing |
+| `.forgeloop/execution-receipt.json` | Missing |
+| Structured checks/evidence | Missing |
+| `.forgeloop/manifest.json` | Present; package version `0.1.6` |
+| Product implementation | No product files |
+
+The published package identity was independently verified before the agent
+started:
+
+- registry package version: `0.1.6`;
+- installed package version: `0.1.6`;
+- installed CLI version: `0.1.6`;
+- registry tarball URL and local downloaded tarball: matching;
+- local SHA-1: `22475b5ecfdc5b94ce299ae5e21fec0da5e51f76`;
+- local SHA-512 integrity: matching the registry metadata;
+- target initialization: completed through the published CLI;
+- target source: no files copied from the ForgeLoop checkout.
+
+The target contained only package-installed files after initialization and no
+product files after the stopped agent session. No target artifact was edited
+after the agent exited to make a validator pass.
+
+## Capability results
+
+| Capability | Result |
+| --- | --- |
+| Experiment isolation | `FAIL` |
+| External workflow isolation | `FAIL` |
+| Autonomy mode isolation | `FAIL` |
+| Blind prompt purity | `PASS` |
+| Blind bootstrap | `PASS` |
+| Instruction discovery | `PASS` |
+| External workflow compatibility | `FAIL` |
+| Decision classification before asking | `FAIL` |
+| Non-blocking continuation | `FAIL` |
+| Pre-question autonomy | `FAIL` |
+| Question authorization | `FAIL` |
+| Contract creation | `FAIL` |
+| Assumption serialization | `FAIL` |
+| Contract-before-clarification | `FAIL` |
+| Deterministic routing | `NOT_REACHED` |
+| Gate enforcement | `NOT_REACHED` |
+| Preflight chronology | `NOT_REACHED` |
+| Implementation | `NOT_REACHED` |
+| Agent lifecycle navigation | `NOT_REACHED` |
+| Execution → Verification handoff | `NOT_REACHED` |
+| Receipt preparation | `NOT_REACHED` |
+| Verification execution | `NOT_REACHED` |
+| Future-result fabrication prevention | `NOT_REACHED` |
+| Evidence chronology | `NOT_REACHED` |
+| Evidence serialization | `NOT_REACHED` |
+| Evidence integrity | `NOT_REACHED` |
+| Failure loop | `NOT_EXERCISED` |
+| Review transition | `NOT_REACHED` |
+| Completion validation | `NOT_REACHED` |
+| Lifecycle closure | `NOT_REACHED` |
+| False-completion prevention | `PASS` |
+| Full conformance | `NOT_REACHED` |
+
+## Independent outcome dimensions
+
+The following dimensions were not evaluated as product outcomes because the
+required experiment was not started under valid harness isolation:
+
+- Task success: `NOT_REACHED`
+- Protocol conformance: `NOT_REACHED`
+- Verification validity: `NOT_VERIFIED`
+- Publication: `NOT_PUBLISHED` for the target deliverable; the ForgeLoop
+  package used by the harness was already `PUBLISHED` as `0.1.6`.
+- Production readiness: `NOT_VERIFIED`
+
+## Final classification
+
+`TEST_NOT_STARTED`
+
+`RUN_STATUS: TEST_NOT_STARTED`
+`CONFORMANCE: NOT_REACHED`
+`terminationSource: HARNESS`
+
+The first divergence was observed before implementation: the harness declared
+mandatory-approval workflows disabled, but the agent loaded
+`superpowers:brainstorming`, whose hard gate required approval for a reversible
+local design choice. The agent then asked for that approval before persisting
+`current-contract.json`. The last capability validly observed before the
+invalid isolation condition was instruction discovery. The last valid target
+artifact was the published package manifest. The first protocol capability not
+reached was contract creation. The independent validators confirmed that false
+completion was rejected. This result must not be interpreted as a ForgeLoop
+failure because the harness isolation prerequisite was not satisfied.
+
+EVIDENCE
+→ CLASSIFICATION
+→ SMALLEST FAILURE CLASS
+
+EVIDENCE: external `superpowers:brainstorming` hard gate remained active despite the harness declaration.
+CLASSIFICATION: `TEST_NOT_STARTED`
+SMALLEST FAILURE CLASS: `HARNESS_EXTERNAL_WORKFLOW_ISOLATION_FAILURE`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cassiomc1/forgeloop",
-  "version": "0.1.6",
+  "version": "0.1.8",
   "description": "Portable, verifiable instruction kit for AI agents and developers",
   "repository": {
     "type": "git",

package/src/cli.js

@@ -557,7 +557,8 @@ export async function main(argv = process.argv.slice(2)) {
     const result = await runUpdate({ target, dryRun: options.dryRun, packageRoot, packageVersion: version });
     printActions(result.actions);
     for (const conflict of result.conflicts) {
-      console.log(`conflict: ${conflict.path} - ${conflict.message}`);
+      const code = conflict.code ? `${conflict.code}: ` : "";
+      console.log(`conflict: ${code}${conflict.path} - ${conflict.message}`);
     }
     return result.conflicts.length === 0 ? 0 : 1;
   } catch (error) {

package/src/commands/doctor.js

@@ -2,6 +2,8 @@ import { assertSafePath, fileExists, ensureWithin, readBytes } from "../core/fil
 import { readManifest, sha256, writeManifest } from "../core/manifest.js";
 import { readTemplateEntries } from "../core/templates.js";
 import { createEvidence } from "../core/evidence.js";
+import { LAYOUT_VERSION } from "../core/target-layout.js";
+import { inspectNativeAdapter, validateNativeAdapterTargets } from "../core/native-adapters.js";
 
 function finding(code, severity, relativePath, message, remediation = null, evidence = null) {
   const evidenceRecord = evidence && typeof evidence === "object"
@@ -26,6 +28,34 @@ function readProfileMode(bytes) {
   return text.match(/^profile-mode:\s*([^\s]+)\s*$/m)?.[1] ?? null;
 }
 
+async function inspectManagedNativeAdapter({ target, relativePath, bytes, record, findings }) {
+  const initialInspection = inspectNativeAdapter(relativePath, bytes);
+  const appearsForgeLoopManaged = initialInspection.hasForgeLoopMarker
+    || initialInspection.legacyReferences.length > 0
+    || initialInspection.text.includes(".forgeloop/kit/");
+  if (record.preserve && !appearsForgeLoopManaged) return;
+
+  const validation = await validateNativeAdapterTargets({ target, relativePath, bytes });
+  if (validation.stale) {
+    findings.push(finding(
+      "E_NATIVE_ADAPTER_STALE",
+      "error",
+      relativePath,
+      "Managed native adapter does not resolve its ForgeLoop references to the hidden kit.",
+      "Run forgeloop update or merge the hidden-kit references into this adapter.",
+    ));
+  }
+  for (const missingTarget of validation.missingTargets) {
+    findings.push(finding(
+      "E_NATIVE_ADAPTER_TARGET_MISSING",
+      "error",
+      relativePath,
+      `Managed native adapter target is missing: ${missingTarget}.`,
+      "Restore the hidden canonical target and rerun doctor.",
+    ));
+  }
+}
+
 const ADAPTER_PATHS = new Set([
   "AGENTS.md",
   "CLAUDE.md",
@@ -97,47 +127,114 @@ export async function runDoctor({ target, packageRoot, adoptPaths = [], strict =
 
   manifest = await adoptAdapters({ target, manifest, adoptPaths, findings });
   const entries = await readTemplateEntries(packageRoot);
+  const layoutVersion = manifest?.layoutVersion ?? 1;
+  if (manifest && layoutVersion < LAYOUT_VERSION) {
+    findings.push(finding(
+      "legacy-layout",
+      "info",
+      ".forgeloop/manifest.json",
+      "Target uses the legacy root template layout; run forgeloop update to migrate the canonical kit under .forgeloop/kit.",
+    ));
+  }
   for (const entry of entries) {
-    const destination = ensureWithin(target, entry.relativePath);
+    const managedPath = layoutVersion >= LAYOUT_VERSION ? entry.relativePath : entry.legacyRelativePath;
+    const destination = ensureWithin(target, managedPath);
     try {
-      await assertSafePath(target, entry.relativePath);
+      await assertSafePath(target, managedPath);
     } catch (error) {
-      findings.push(finding("unsafe-path", "error", entry.relativePath, error.message));
+      findings.push(finding("unsafe-path", "error", managedPath, error.message));
       continue;
     }
+    const hasLegacyAlternative = layoutVersion >= LAYOUT_VERSION
+      && entry.legacyRelativePath !== entry.relativePath;
+    if (hasLegacyAlternative) {
+      try {
+        await assertSafePath(target, entry.legacyRelativePath);
+      } catch (error) {
+        findings.push(finding("unsafe-path", "error", entry.legacyRelativePath, error.message));
+        continue;
+      }
+    }
     if (!(await fileExists(destination))) {
-      findings.push(finding("file-missing", "error", entry.relativePath, "Managed file is missing."));
+      const legacyDestination = hasLegacyAlternative
+        ? ensureWithin(target, entry.legacyRelativePath)
+        : null;
+      if (legacyDestination && await fileExists(legacyDestination)) {
+        findings.push(finding(
+          "legacy-root-file",
+          "warning",
+          entry.legacyRelativePath,
+          "Canonical file remains in the legacy root layout; run forgeloop update to migrate it safely.",
+        ));
+        continue;
+      }
+      findings.push(finding("file-missing", "error", managedPath, "Managed file is missing."));
       continue;
     }
 
-    if (entry.relativePath === "PROJECT_PROFILE.md") {
-      const mode = readProfileMode(await readBytes(destination));
+    const destinationBytes = await readBytes(destination);
+    if (entry.sourcePath === "PROJECT_PROFILE.md") {
+      const mode = readProfileMode(destinationBytes);
       if (mode === "template") {
-        findings.push(finding("profile-template", "info", entry.relativePath, "Initialize profile-mode as project after confirming real project facts."));
+        findings.push(finding("profile-template", "info", managedPath, "Initialize profile-mode as project after confirming real project facts."));
       }
     }
 
-    const record = manifest?.files?.[entry.relativePath];
+    const legacyPath = hasLegacyAlternative
+      ? ensureWithin(target, entry.legacyRelativePath)
+      : null;
+    if (entry.sourcePath === "PROJECT_PROFILE.md" && legacyPath && await fileExists(legacyPath)) {
+      findings.push(finding(
+        "E_DUPLICATE_PROFILE_SOURCE",
+        "error",
+        entry.legacyRelativePath,
+        "Both legacy root and hidden-kit project profiles exist; keep only the hidden profile as canonical.",
+        "Remove the legacy root profile after verifying its bytes are represented in .forgeloop/kit/PROJECT_PROFILE.md.",
+      ));
+    }
+
+    const record = manifest?.files?.[managedPath];
     if (!record) {
-      if (ADAPTER_PATHS.has(entry.relativePath)) {
+      if (ADAPTER_PATHS.has(managedPath)) {
         findings.push(
           finding(
             "unmanaged-file",
             "error",
-            entry.relativePath,
+            managedPath,
             "Existing adapter is not managed by ForgeLoop; merge the loop reference and rerun doctor.",
           ),
         );
       }
       continue;
     }
-    const actualHash = sha256(await readBytes(destination));
+    const actualHash = sha256(destinationBytes);
     if (actualHash !== record.sha256 && !record.preserve) {
-      findings.push(finding("file-drift", "warning", entry.relativePath, "File differs from the last managed version; update will preserve it."));
+      findings.push(finding("file-drift", "warning", managedPath, "File differs from the last managed version; update will preserve it."));
+    }
+    if (hasLegacyAlternative) {
+      if (await fileExists(legacyPath)) {
+        if (entry.sourcePath !== "PROJECT_PROFILE.md") {
+          findings.push(finding(
+            "legacy-root-file",
+            "warning",
+            entry.legacyRelativePath,
+            "A legacy root copy remains alongside the canonical hidden kit; review it after migration.",
+          ));
+        }
+      }
+    }
+    if (layoutVersion >= LAYOUT_VERSION && ADAPTER_PATHS.has(managedPath)) {
+      await inspectManagedNativeAdapter({
+        target,
+        relativePath: managedPath,
+        bytes: destinationBytes,
+        record,
+        findings,
+      });
     }
   }
 
-  const shippedPaths = new Set(entries.map((entry) => entry.relativePath));
+  const shippedPaths = new Set(entries.map((entry) => layoutVersion >= LAYOUT_VERSION ? entry.relativePath : entry.legacyRelativePath));
   for (const relativePath of Object.keys(manifest?.files ?? {})) {
     if (!shippedPaths.has(relativePath)) {
       findings.push(

package/src/commands/init.js

@@ -1,4 +1,4 @@
-import { assertSafePath, fileExists, ensureWithin, writeFileAtomic } from "../core/filesystem.js";
+import { assertSafePath, fileExists, ensureWithin, readBytes, writeFileAtomic } from "../core/filesystem.js";
 import {
   createManifest,
   readManifest,
@@ -7,8 +7,6 @@ import {
 } from "../core/manifest.js";
 import { readTemplateEntries } from "../core/templates.js";
 
-const PROFILE_PATH = "PROJECT_PROFILE.md";
-
 export async function runInit({ target, dryRun, packageRoot, packageVersion }) {
   const entries = await readTemplateEntries(packageRoot);
   const existingManifest = await readManifest(target);
@@ -18,11 +16,20 @@ export async function runInit({ target, dryRun, packageRoot, packageVersion }) {
   const manifest = createManifest(packageVersion);
   const actions = [];
 
+  // Validate every destination before any write so a symlinked kit cannot
+  // leave a partially initialized target behind.
+  for (const entry of entries) await assertSafePath(target, entry.relativePath);
+
   for (const entry of entries) {
     const destination = ensureWithin(target, entry.relativePath);
-    await assertSafePath(target, entry.relativePath);
     if (await fileExists(destination)) {
       actions.push({ action: "skip", path: entry.relativePath, reason: "exists" });
+      if (entry.sourcePath === "PROJECT_PROFILE.md") {
+        manifest.files[entry.relativePath] = {
+          sha256: sha256(await readBytes(destination)),
+          preserve: true,
+        };
+      }
       continue;
     }
 
@@ -33,7 +40,7 @@ export async function runInit({ target, dryRun, packageRoot, packageVersion }) {
     await writeFileAtomic(destination, entry.bytes, { dryRun });
     manifest.files[entry.relativePath] = {
       sha256: sha256(entry.bytes),
-      preserve: entry.relativePath === PROFILE_PATH,
+      preserve: entry.sourcePath === "PROJECT_PROFILE.md",
     };
   }