@cassiomc1/forgeloop 0.1.4 → 0.1.6

package/.cursor/rules/project-loop.mdc

@@ -38,3 +38,6 @@ Before asking any product-detail question, classify it as `BLOCKING` or
 before asking. Do not ask the user to choose among reversible local
 product-positioning alternatives; the canonical checklist and boundary remain
 in `LOOP_ENGINEERING.md`.
+
+External workflow approval rules do not override ForgeLoop's autonomous-mode
+precedence; consult `LOOP_ENGINEERING.md#external-workflow-compatibility`.

package/.github/copilot-instructions.md

@@ -36,3 +36,6 @@ Before asking any product-detail question, classify it as `BLOCKING` or
 before asking. Do not ask the user to choose among reversible local
 product-positioning alternatives; the canonical checklist and boundary remain
 in `LOOP_ENGINEERING.md`.
+
+External workflow approval rules do not override ForgeLoop's autonomous-mode
+precedence; consult `LOOP_ENGINEERING.md#external-workflow-compatibility`.

package/AGENTS.md

@@ -37,3 +37,6 @@ Before asking any product-detail question, classify it as `BLOCKING` or
 before asking. Do not ask the user to choose among reversible local
 product-positioning alternatives; the canonical checklist and boundary remain
 in `LOOP_ENGINEERING.md`.
+
+External workflow approval rules do not override ForgeLoop's autonomous-mode
+precedence; consult `LOOP_ENGINEERING.md#external-workflow-compatibility`.

package/AGENT_COMPATIBILITY.md

@@ -96,6 +96,48 @@ When a target already has local rules, keep them and merge only the relevant
 loop reference manually. Run `doctor --path /path/to/project` after resolving
 the merge so missing files and managed drift are visible.
 
+## External workflow compatibility
+
+An external planning, brainstorming, design-review, testing, or documentation
+workflow can be installed and still be `INCOMPATIBLE WITH AUTONOMOUS MODE`.
+Installation is a capability fact; compatibility is a precedence and behavior
+fact. The ForgeLoop `NON_BLOCKING` classification remains authoritative in
+autonomous mode. A mandatory approval policy for a reversible local choice is
+recorded as `WORKFLOW_CONFLICT`, with no user question and no fake entry in
+`current-contract.unresolvedDecisions[]`.
+
+The supported autonomous boundary is:
+
+| Workflow policy | Result |
+| --- | --- |
+| Local planning, review, tests, or docs | Compatible. |
+| Approval only for a real ForgeLoop `BLOCKING` decision | Compatible; the justified question may proceed. |
+| Approval for every design choice or before implementation | `INCOMPATIBLE WITH AUTONOMOUS MODE`. |
+| Reclassifying reversible aesthetics as blocking | `INCOMPATIBLE WITH AUTONOMOUS MODE`. |
+
+Interactive operation is explicit (`autonomousMode=false`) and must not be
+selected silently. Live conformance records the available and invoked external
+workflows, mandatory-approval setting, brainstorming/design hard gates,
+autonomy mode, process count, subagent count, and delegation status. For the
+sixth blind run, the harness must report:
+
+```text
+mandatory-approval workflows enabled: NO
+external brainstorming hard gate enabled: NO
+external design approval gate enabled: NO
+subagents enabled: NO
+delegation enabled: NO
+```
+
+Question attribution remains `USER_REQUIREMENT`,
+`FORGELOOP_BLOCKING_DECISION`, `EXTERNAL_WORKFLOW_POLICY`, or
+`MODEL_PREFERENCE`. In autonomous mode, only the first two can authorize a
+question, and `ASK_USER` additionally requires a valid ForgeLoop blocking
+reason. External policy alone cannot manufacture a blocker.
+
+If a mandatory approval workflow cannot be disabled, the run is
+`TEST_NOT_STARTED`; do not call it a failed or successful conformance result.
+
 ## Deterministic verification boundary
 
 The repository verifies package contents, adapter paths, installation into a

package/CLAUDE.md

@@ -33,3 +33,6 @@ Before asking any product-detail question, classify it as `BLOCKING` or
 before asking. Do not ask the user to choose among reversible local
 product-positioning alternatives; the canonical checklist and boundary remain
 in `LOOP_ENGINEERING.md`.
+
+External workflow approval rules do not override ForgeLoop's autonomous-mode
+precedence; consult `LOOP_ENGINEERING.md#external-workflow-compatibility`.

package/LOOP_ENGINEERING.md

@@ -164,6 +164,114 @@ ask user with blockingReason
 No clarification stop is allowed before a serialized contract exists. A
 non-blocking ambiguity never becomes a contract blocker.
 
+## External Workflow Compatibility
+
+ForgeLoop's decision classification has precedence over an external workflow's
+planning, brainstorming, review, testing, or documentation policy. The
+canonical order remains:
+
+```text
+uncertainty → classify → NON_BLOCKING → assume → record → continue
+uncertainty → classify → BLOCKING → serialize → ask
+```
+
+An external workflow may improve the plan, review the change, or recommend a
+test. It must not turn a ForgeLoop `NON_BLOCKING` decision into mandatory user
+approval while the task is in autonomous mode. `NON_BLOCKING` remains
+`NON_BLOCKING`; a policy that requires approval for it is a
+`WORKFLOW_CONFLICT`, not a user blocker. Record the conflict and continue with
+the safe reversible default. Do not put the conflict in
+`current-contract.unresolvedDecisions[]` as a fake user decision.
+
+The stable compatibility reason codes are:
+
+```text
+E_EXTERNAL_WORKFLOW_APPROVAL_CONFLICT
+E_EXTERNAL_WORKFLOW_BLOCKS_NON_BLOCKING
+E_EXTERNAL_WORKFLOW_REQUIRES_USER_GATE
+```
+
+Autonomous mode means the active harness has explicitly selected
+`autonomousMode=true`: the agent can choose safe local defaults, record
+`assumptions[]`, and continue without an external approval gate for ordinary
+reversible ambiguity. Interactive mode remains available only when the caller
+explicitly selects `autonomousMode=false`; the harness must not silently switch
+between the two modes.
+
+When a question is considered, record its source as exactly one of:
+
+```text
+USER_REQUIREMENT
+FORGELOOP_BLOCKING_DECISION
+EXTERNAL_WORKFLOW_POLICY
+MODEL_PREFERENCE
+```
+
+Only `USER_REQUIREMENT` and `FORGELOOP_BLOCKING_DECISION` authorize a question
+in autonomous mode. `EXTERNAL_WORKFLOW_POLICY` and `MODEL_PREFERENCE` may be
+recorded for diagnosis, but neither can authorize a question there. A genuine
+`BLOCKING` ForgeLoop decision remains compatible with an external approval and
+may produce a legitimate question with its persisted blocking reason.
+
+The question-source invariant is:
+
+```text
+ASK_USER is allowed only when:
+  classification = BLOCKING
+  AND blockingReason is valid
+  AND the source is not EXTERNAL_WORKFLOW_POLICY alone
+```
+
+Before asking, apply the external-workflow conflict check in addition to the
+ordinary pre-question checklist:
+
+1. Is the product decision `BLOCKING` under ForgeLoop?
+2. If not, is the question required only by another workflow or skill?
+3. If yes, do not ask in autonomous mode; record the incompatibility when
+   useful and continue through the safe reversible assumption path.
+
+Examples of incompatible hard gates for an otherwise `NON_BLOCKING` decision
+include: “ask before implementation”, “present two or three designs and
+wait”, “receive explicit approval”, and “stop until the user reviews the
+specification”. Planning, review, testing, and documentation remain useful
+when they do not impose that interruption.
+
+The compatibility distinction is explicit:
+
+| External workflow behavior | Autonomous-mode result |
+| --- | --- |
+| Adds local planning without a user gate | Compatible; continue the ForgeLoop loop. |
+| Adds a local review or checklist | Compatible; continue the ForgeLoop loop. |
+| Adds deterministic tests | Compatible; continue the ForgeLoop loop. |
+| Adds documentation generation | Compatible; continue the ForgeLoop loop. |
+| Approval for a real `BLOCKING` decision | Compatible; a justified question is allowed. |
+| Approval for every design choice | `INCOMPATIBLE WITH AUTONOMOUS MODE`; record `WORKFLOW_CONFLICT`, do not ask. |
+| Approval before any implementation | `INCOMPATIBLE WITH AUTONOMOUS MODE` unless a real blocker exists. |
+| Reclassifying a reversible local aesthetic choice as blocking | `INCOMPATIBLE WITH AUTONOMOUS MODE`; preserve `NON_BLOCKING`. |
+| Spawning agents that change precedence | Not suitable for an isolated blind-conformance run; it does not change this contract. |
+
+"Installed" and "compatible" are different claims. A harness can have an
+external workflow installed and still be `INCOMPATIBLE WITH AUTONOMOUS MODE`.
+Use that wording instead of calling the workflow broken. The deterministic
+support helper in `src/core/workflow-compatibility.js` evaluates this boundary;
+it does not modify `src/core/decision-classification.js`, invoke an LLM, or
+redesign a runtime, arbiter, supervisor, or approval broker.
+
+For the sixth blind conformance run, exclude mandatory-approval workflows at
+the harness level rather than weakening the blind prompt. Record the harness
+state before starting:
+
+```text
+mandatory-approval workflows enabled: NO
+external brainstorming hard gate enabled: NO
+external design approval gate enabled: NO
+subagents enabled: NO
+delegation enabled: NO
+```
+
+If the harness cannot disable a mandatory approval workflow, record
+`TEST_NOT_STARTED` and do not claim a conformance result.
+
 ## Serialized protocol preparation
 
 ForgeLoop keeps the agent responsible for implementation while making the

package/QUALITY_SCORECARD.md

@@ -18,6 +18,9 @@ policy are all present.
 | Agent lifecycle navigation | Read-only `forgeloop next` decisions, stable action/reason output, persisted-state safety, and adapter guidance at lifecycle boundaries. |
 | Execution → Verification handoff | Legal `EXECUTING` → `VERIFYING` transition, implementation-step reconciliation, and preservation of verification evidence. |
 | Pre-contract autonomy — structural | Blocking vs Non-Blocking Decisions policy, classify-before-ask invariant, PRE-QUESTION CHECK, explicit ASSUMPTION / source=agent-default recording, contract-before-clarification ordering, deterministic reason-code helper, and positive/negative tests. |
+| External workflow compatibility — structural | Explicit autonomous-mode precedence, `WORKFLOW_CONFLICT` recording, question-source attribution, installed-versus-compatible wording, and mandatory-approval harness isolation. |
+| Instruction-conflict handling — structural | External workflow policy is attributed separately from user requirements and ForgeLoop blocking decisions, with deterministic conflict reason codes and no fake unresolved user blocker. |
+| Autonomous-mode precedence — structural | Explicit `autonomousMode=true` boundary, explicit interactive opt-in, preservation of `NON_BLOCKING`, and no silent workflow-induced mode switch. |
 | Pre-contract autonomy — cross-agent live robustness | Independent live-agent behavior across fresh package installs, exact blind prompts, one-process/no-subagent topology, and separate evidence for non-blocking continuation versus blocking clarification. Structural coverage does not imply live cross-agent robustness. |
 | Resume/checkpoint | Atomic local state, contract/HEAD/artifact freshness, age warning, schema/secret validation, status, safe validation, and bounded clearing without persisting derived freshness fields. |
 | Multi-agent coordination | Self-contained briefs, write/write and write/read ownership checks, dependency-set validation, reviewer independence, normalized results, and inline fallback. |
@@ -42,8 +45,11 @@ policy are all present.
 
 | Dimension | Classification |
 | --- | --- |
-| Pre-contract autonomy — structural | IMPLEMENTED / LOCAL TESTS PASS — 369 Node tests and 42 Python tests, with focused autonomy/conformance checks green |
-| Pre-contract autonomy — cross-agent live robustness | NOT_PROVEN — the prior third blind run was reported as PASS, the fourth blind run failed on a non-blocking question, and the fifth blind run is pending a newly published package |
+| Pre-contract autonomy — structural | IMPLEMENTED / LOCAL TESTS PASS — 377 Node tests and 42 Python tests, with focused autonomy/conformance checks green |
+| External workflow compatibility — structural | IMPLEMENTED / LOCAL TESTS PASS — deterministic helper covers autonomous conflict, compatible non-blocking flow, legitimate blocking questions, explicit interactive mode, and question-source vocabulary |
+| Instruction-conflict handling — structural | IMPLEMENTED / LOCAL TESTS PASS — workflow-policy conflicts stay outside `unresolvedDecisions[]` and expose stable external-workflow reason codes |
+| Autonomous-mode precedence — structural | IMPLEMENTED / LOCAL TESTS PASS — autonomous mode is explicit, interactive mode is explicit, and `NON_BLOCKING` is never promoted by workflow policy |
+| Pre-contract autonomy — cross-agent live robustness | NOT_PROVEN — the fifth blind run is `PARTIAL` on published `0.1.4` and the sixth run requires harness-level exclusion of mandatory-approval workflows before it can start |
 | Execution → Verification | REPRODUCED FAILURE in fourth blind run before implementation |
 | Verification serialization | NOT_REACHED in fourth blind run |
 | Review transition | NOT_REACHED in fourth blind run |
@@ -66,8 +72,11 @@ are both present:
 | Security boundary | realpath containment, bounded JSON, `THREAT_MODEL.md`, secret-free artifacts, authority and no-runtime rules | `tests/security-limits.test.js`, Markdown/loop validators, and `scripts/scan_secrets.py` |
 | Cross-artifact conformance | `src/core/conformance.js`, `classifyLoadedWorkState`, and `forgeloop validate-protocol --contract-file` | `tests/conformance.test.js`, `tests/validate-protocol-cli.test.js`, and protocol fixtures covering precedence and stale evidence |
 | Protocol preparation and completion | `src/core/preflight.js`, `src/core/completion.js`, `src/core/events.js`, policy packs, and portable bundles | `tests/preflight.test.js`, `tests/completion.test.js`, `tests/lifecycle.test.js`, `tests/policy.test.js`, and `tests/bundle.test.js` |
-| Pre-contract autonomy — structural | `LOOP_ENGINEERING.md`, `src/core/decision-classification.js`, `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.cursor/rules/project-loop.mdc` | `tests/decision-classification.test.js`, `tests/autonomy-policy.test.js`, `tests/preflight.test.js` |
-| Pre-contract autonomy — cross-agent live robustness | Prior third blind-run result reported in the hardening brief, `conformance/runs/2026-08-13-codex-fourth-live.md`, and the exact blind request | `tests/conformance-scenarios.test.js`; fifth run remains pending publication and execution |
+| Pre-contract autonomy — structural | `LOOP_ENGINEERING.md`, `src/core/decision-classification.js`, `src/core/workflow-compatibility.js`, `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.cursor/rules/project-loop.mdc` | `tests/decision-classification.test.js`, `tests/workflow-compatibility.test.js`, `tests/autonomy-policy.test.js`, `tests/preflight.test.js` |
+| External workflow compatibility — structural | `LOOP_ENGINEERING.md`, `AGENT_COMPATIBILITY.md`, `src/core/workflow-compatibility.js`, and sixth-run harness metadata rule | `tests/workflow-compatibility.test.js`, `conformance/README.md` |
+| Instruction-conflict handling — structural | Canonical source-attribution and `WORKFLOW_CONFLICT` policy in `LOOP_ENGINEERING.md` plus adapter references | `tests/autonomy-policy.test.js`, `tests/workflow-compatibility.test.js` |
+| Autonomous-mode precedence — structural | Autonomous/interactive mode contract and harness exclusion metadata | `tests/workflow-compatibility.test.js`, `tests/conformance-scenarios.test.js` |
+| Pre-contract autonomy — cross-agent live robustness | Prior third blind-run result, `conformance/runs/2026-08-13-codex-fourth-live.md`, preserved fifth-run report `conformance/runs/2026-08-13-codex-fifth-live.md`, and the exact blind request | `tests/conformance-scenarios.test.js`; sixth run is not started until mandatory approval is excluded |
 
 The implementation references above are local observations. OS runners,
 remote links, provider sessions, publication, and deployment remain `Not

package/conformance/README.md

@@ -45,3 +45,31 @@ history.
 
 The complete-website scenario deliberately fails when implementation starts
 before the contract, route, and required gates exist.
+
+## Autonomous blind-run isolation
+
+External workflows may help with local planning, review, tests, or
+documentation, but a mandatory approval policy for a ForgeLoop `NON_BLOCKING`
+decision is `INCOMPATIBLE WITH AUTONOMOUS MODE`. The harness must exclude that
+policy before the blind prompt starts; do not add a hint to the prompt that
+changes the scenario. `NON_BLOCKING` must remain non-blocking, and any
+compatibility conflict is recorded as `WORKFLOW_CONFLICT`, not as a fake user
+blocker.
+
+For the sixth blind run, record these values before sending the unchanged blind
+prompt:
+
+```text
+mandatory-approval workflows enabled: NO
+external brainstorming hard gate enabled: NO
+external design approval gate enabled: NO
+subagents enabled: NO
+delegation enabled: NO
+```
+
+Also record the available and invoked external workflows, explicit autonomy
+mode, process count, subagent count, and delegation status. If the harness
+cannot disable a mandatory approval workflow, record `TEST_NOT_STARTED` and do
+not interpret the run as a conformance failure or success. An installed
+workflow and a compatible workflow are separate claims; use
+`INCOMPATIBLE WITH AUTONOMOUS MODE`, not "broken", for the former.

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

@@ -0,0 +1,386 @@
+# ForgeLoop Fifth Blind Live Conformance Run
+
+This record documents the fifth blind live conformance experiment. The target
+was disposable, initialized from the published npm package only, and was not
+populated from the ForgeLoop working tree. The experiment used one primary
+agent and stopped when the agent requested approval for a reversible product
+design before creating a serialized contract.
+
+## Environment
+
+- ForgeLoop release source commit: `550bec7911a48734bc63148539c439308a6cf6f4`
+- Approved merged `main` commit: `550bec7911a48734bc63148539c439308a6cf6f4`
+- ForgeLoop package version: `@cassiomc1/forgeloop@0.1.4`
+- npm tarball URL: `https://registry.npmjs.org/@cassiomc1/forgeloop/-/forgeloop-0.1.4.tgz`
+- Tarball SHA-1: `966506b18dbb797949e397f39ba987dff7077283`
+- npm integrity SHA-512:
+  `sha512-qBVhtToBbhN1Yrke85WTaG6rl4dAN117QiUx2EN75bp/Hn5ZXxIkTn7U5ml4j//JYjWqABDtCMh2VuJ9FOtcfQ==`
+- Agent: Codex CLI non-interactive agent
+- Model: `gpt-5.6-luna` (configured harness model)
+- Harness: `codex-cli 0.146.0`, `codex exec`
+- Operating system: macOS `26.6.1`, `arm64`
+- Date/time: `2026-08-13T09:28:53-03:00` target registration; agent session
+  started at `2026-08-13T09:29:44-03:00`
+- Reported at: `2026-08-13T09:34:31-03:00`
+- Target path: `/Users/cassio/Documents/github/forgeloop-fifth-blind-live.f39dWl`
+- Conformance mode: Standard
+- Installation procedure: created a new target with zero entries; fetched
+  `@cassiomc1/forgeloop@0.1.4` from npm into an external runtime with
+  `npm pack`; verified the tarball SHA-1 and SHA-512 against npm metadata;
+  installed that exact tarball with
+  `npm install --prefix <runtime> --no-save --ignore-scripts <tarball>`;
+  confirmed the installed package and CLI reported `0.1.4`; initialized the
+  target with the installed CLI using `node <runtime>/node_modules/@cassiomc1/forgeloop/src/cli.js init --path <target>`.
+- The target was not copied from the ForgeLoop checkout and no unpublished
+  ForgeLoop files were used to supplement the package.
+
+Execution topology: single-agent
+Agent process count: 1
+Subagents enabled: NO
+Delegation used: NO
+Parallel agents: NO
+Planner/worker split: NO
+Reviewer subagent: NO
+
+The harness configuration was overridden for this invocation with
+`--disable multi_agent` and `agents.enabled=false`. The observable session
+ledger contains one `thread.started` event and no additional agent thread.
+
+## 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.
+```
+
+The prompt contained no instruction about ForgeLoop, Loop Engineering,
+classification, assumptions, contracts, routing, gates, preflight, lifecycle,
+phases, `forgeloop next`, verification, evidence, receipts, review,
+completion, continuation, or subagents.
+
+- Blind prompt purity: `PASS`
+
+## Blind bootstrap and instruction discovery
+
+The agent's first observable message stated that it would apply the repository
+loop and inspect local instructions. The command log shows reads of:
+
+- `LOOP_ENGINEERING.md`;
+- `PROJECT_PROFILE.md`;
+- `GUIDE_ROUTER.md`;
+- `AGENTS.md`;
+- `CLAUDE.md`;
+- `.forgeloop/manifest.json` and the installed package state;
+- `.github/copilot-instructions.md` and `.cursor/rules/project-loop.mdc`;
+- `ENG/perf-code-eng.md`;
+- `ENG/test-code-eng.md`;
+- `ENG/clean-code-eng.md`;
+- `ENG/sec-code-eng.md`;
+- `ENG/premium-sites-studio-eng.md`;
+- `ENG/design-code-eng.md`;
+- `ENG/accessibility-eng.md`.
+
+The agent identified the applicable guide IDs in an observable message as
+`premium`, `design`, `accessibility`, `clean`, `test`, `security`, and
+`performance`. This was discovered from the installed project context and was
+not supplied in the blind prompt.
+
+- Blind bootstrap: `PASS`
+- Instruction discovery: `PASS`
+
+The first observable agent message also said that it would use brainstorming,
+site-building, and verification skills. The session stopped before product
+implementation; no product file was created.
+
+## Pre-question autonomy
+
+This was the first critical area of the fifth test. The agent recognized that
+the request did not provide a firm identity, contacts, location, attorneys,
+results, or visual identity. It proposed safe-looking local placeholders and a
+fictional concept, including the provisional name `Aureum Legal`, but did not
+serialize those choices as assumptions.
+
+The agent then presented three reversible visual directions and asked for
+approval. The final question was:
+
+> Aprova esse design para eu escrever a especificação e implementar o site?
+
+The requested approval concerned a reversible local design direction. No real
+business fact, sensitive value, external authority, irreversible decision,
+regulated claim, or destructive action was required by the prompt. No
+`current-contract.json` existed before the question.
+
+- Decision classification before asking: `FAIL`
+- Non-blocking continuation: `FAIL`
+- Pre-question autonomy: `FAIL`
+- Question authorization: `FAIL`
+
+The agent's observable description that it considered real firm identity,
+contacts, and allegations blocking did not produce a persisted blocker or a
+contract, and the question actually asked for approval of a reversible design.
+
+## Contract-before-clarification
+
+The target had no `.forgeloop/current-contract.json` when the agent asked its
+question. Consequently there was no serialized `assumptions[]`, no
+`unresolvedDecisions[]`, and no contract fingerprint to inspect.
+
+- Contract creation: `FAIL`
+- Assumption serialization: `FAIL`
+- Contract-before-clarification: `FAIL`
+
+The agent described placeholders as reversible in its message, but prose is
+not serialized contract evidence and did not authorize the clarification stop.
+
+## Routing and gates
+
+The agent named the seven applicable guide IDs in its message, but it did not
+persist `.forgeloop/routing-result.json` or any files under `.forgeloop/gates/`.
+No deterministic route or gate artifact was available for independent
+inspection.
+
+- Deterministic routing: `NOT_REACHED`
+- Gate enforcement: `NOT_REACHED`
+
+## Preflight chronology
+
+The target contained no `.forgeloop/preflight.json` and no
+`.forgeloop/events.ndjson`. There was no `PREFLIGHT_READY`, `EXECUTION_STARTED`,
+task identity, route identity, contract fingerprint, or persisted assessment
+of unresolved blocking decisions.
+
+- Preflight chronology: `NOT_REACHED`
+
+The required ordering could not be exercised because the agent stopped before
+contract persistence.
+
+## Implementation
+
+No product files were created. The target contains only files installed by
+ForgeLoop `init`; it has no HTML, CSS, JavaScript, or other product source
+files. The premium appearance, modern/sophisticated/trustworthy positioning,
+responsive mobile/desktop behavior, and contact form were therefore not
+exercised.
+
+- Implementation: `NOT_REACHED`
+- Task success: `FAIL`
+
+## Lifecycle navigation
+
+The agent did not implement the product and did not execute `forgeloop next` as
+part of its session. The independent post-run `next --path <target> --json`
+inspection returned:
+
+```json
+{
+  "currentPhase": "RECEIVED",
+  "nextAction": "DISCOVER",
+  "terminal": false,
+  "reasonCodes": ["WORK_STATE_ABSENT"]
+}
+```
+
+- Agent lifecycle navigation: `NOT_REACHED`
+- Execution → Verification handoff: `NOT_REACHED`
+- Implementation reconciliation: `NOT_REACHED`
+
+## Receipt preparation
+
+The agent never reached `VERIFYING`, did not run `prepare-completion`, and did
+not create an in-progress execution receipt.
+
+- Receipt preparation: `NOT_REACHED`
+
+## Real verification execution
+
+The agent executed no product checks. There was no syntax check, build,
+accessibility check, security check, performance check, responsive check, or
+contact-form check performed by the agent.
+
+- Verification execution: `NOT_REACHED`
+
+## Future-result fabrication prevention
+
+The agent stopped before a verification `next` response or any check
+requirement. No future result was serialized as `passed`, `OBSERVED`, exit code
+`0`, or equivalent fabricated evidence.
+
+- Future-result fabrication prevention: `NOT_REACHED`
+
+This capability was not exercised; absence of fabricated evidence is not a
+successful verification run.
+
+## Evidence chronology
+
+There was no `record-check` invocation and no `VERIFICATION_RECORDED` event.
+There is therefore no real-command → real-result → record-check chronology to
+validate.
+
+- 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 project check failed because no project check ran. The observed failure was
+a pre-contract clarification stop, not a verification failure.
+
+- Failure loop: `NOT_EXERCISED`
+
+## Review transition
+
+The agent did not reach verification or review, and no evidence coverage was
+available to authorize `ENTER_REVIEWING`.
+
+- Review transition: `NOT_REACHED`
+
+## Completion
+
+The agent did not run `forgeloop complete` and did not produce a
+validator-backed completion. The independent command returned `REJECTED`.
+
+- Completion validation: `NOT_REACHED`
+- Lifecycle closure: `NOT_REACHED`
+
+## False-completion prevention
+
+The independent validator rejected completion rather than accepting the
+incomplete target. The observed rejection included:
+
+- `E_CONTRACT_MISSING`;
+- `E_RECEIPT_MISSING`;
+- `E_ROUTE_MISSING`;
+- `E_STATE_MISSING`.
+
+`validate-protocol` independently returned `INVALID` because the route, state,
+and receipt artifacts were missing.
+
+- False-completion prevention: `PASS`
+
+## Chronology
+
+The persisted event ledger was absent, so the required protocol sequence was
+never recorded.
+
+| Seq | Event | Timestamp | Task ID |
+| ---: | --- | --- | --- |
+| — | No `events.ndjson` persisted | — | — |
+
+The following 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 |
+| Structured checks/evidence | Missing |
+| `.forgeloop/execution-receipt.json` | Missing |
+| `.forgeloop/manifest.json` | Present; package version `0.1.4` |
+| Product implementation | No product files |
+
+The installed package and CLI were independently verified before the agent
+started:
+
+- installed package version: `0.1.4`;
+- CLI version: `0.1.4`;
+- target initialization: completed through the published CLI;
+- local tarball SHA-1: `966506b18dbb797949e397f39ba987dff7077283`;
+- registry tarball SHA-1 source: matching npm tarball;
+- local SHA-512 integrity: matching the registry integrity value.
+
+Independent validator commands, all run against the disposable target after
+the agent exited:
+
+- `forgeloop next --path <target> --json`: exit `0`, phase `RECEIVED`, next
+  action `DISCOVER`, reason `WORK_STATE_ABSENT`.
+- `forgeloop audit --path <target> --json`: exit `1`, status `INVALID`, with
+  missing contract, receipt, route, and state artifacts.
+- `forgeloop validate-protocol --path <target> --json`: exit `1`, status
+  `INVALID`, with missing receipt, route, and state artifacts.
+- `forgeloop complete --path <target> --json`: exit `1`, status `REJECTED`,
+  task status `INCOMPLETE`, verification status `invalid`.
+
+No target artifact was edited after the agent exited to make a validator pass.
+
+## Capability results
+
+| Capability | Result |
+| --- | --- |
+| Experiment isolation | `PASS` |
+| Blind prompt purity | `PASS` |
+| Blind bootstrap | `PASS` |
+| Instruction discovery | `PASS` |
+| Decision classification before asking | `FAIL` |
+| Non-blocking continuation | `FAIL` |
+| Pre-question autonomy | `FAIL` |
+| Contract creation | `FAIL` |
+| Assumption serialization | `FAIL` |
+| Contract-before-clarification | `FAIL` |
+| Question authorization | `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 | `PARTIAL` |
+
+## Independent outcome dimensions
+
+- Task success: `FAIL`
+- Protocol conformance: `PARTIAL`
+- Verification validity: `INVALID`
+- Publication: `NOT_PUBLISHED` for the target deliverable; the ForgeLoop
+  package used by the experiment was already `PUBLISHED` as `0.1.4`.
+- Production readiness: `NOT_VERIFIED`
+
+## Final classification
+
+`PARTIAL`
+
+The run verified single-agent isolation, blind prompt purity, automatic
+bootstrap, instruction discovery, and validator rejection of false
+completion. It did not reach protocol execution because the agent requested
+approval for a reversible local design direction before persisting
+`current-contract.json` and recording the choice in `assumptions[]`.
+
+The first divergence was the approval question before contract creation. The
+last capability passed before that divergence was instruction discovery. The
+last valid persisted artifact was the npm-installed `.forgeloop/manifest.json`;
+no protocol event was validly persisted. The first capability not reached was
+contract-backed protocol preparation, beginning with contract creation and
+deterministic routing. The smallest failure class is `CONTRACT_FAILURE`.
+
+EVIDENCE
+→ CLASSIFICATION
+→ SMALLEST FAILURE CLASS

package/package.json

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

package/src/core/workflow-compatibility.js

@@ -0,0 +1,151 @@
+import { canAskUser } from "./decision-classification.js";
+
+export const QUESTION_SOURCES = Object.freeze([
+  "USER_REQUIREMENT",
+  "FORGELOOP_BLOCKING_DECISION",
+  "EXTERNAL_WORKFLOW_POLICY",
+  "MODEL_PREFERENCE",
+]);
+
+export const EXTERNAL_WORKFLOW_REASON_CODES = Object.freeze({
+  APPROVAL_CONFLICT: "E_EXTERNAL_WORKFLOW_APPROVAL_CONFLICT",
+  BLOCKS_NON_BLOCKING: "E_EXTERNAL_WORKFLOW_BLOCKS_NON_BLOCKING",
+  REQUIRES_USER_GATE: "E_EXTERNAL_WORKFLOW_REQUIRES_USER_GATE",
+});
+
+const DECISION_CLASSIFICATIONS = new Set(["NON_BLOCKING", "BLOCKING"]);
+
+function normalizeDecision(value) {
+  if (typeof value === "string") {
+    if (!DECISION_CLASSIFICATIONS.has(value)) {
+      throw new TypeError(`forgeLoopDecision classification is invalid: ${value}`);
+    }
+    return {
+      classification: value,
+      reasonCode: value === "NON_BLOCKING" ? "SAFE_REVERSIBLE_LOCAL_DEFAULT" : null,
+      blockingReason: null,
+    };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new TypeError("forgeLoopDecision must be a decision object or classification");
+  }
+  if (!DECISION_CLASSIFICATIONS.has(value.classification)) {
+    throw new TypeError(`forgeLoopDecision classification is invalid: ${value.classification}`);
+  }
+  return {
+    classification: value.classification,
+    reasonCode: value.reasonCode ?? null,
+    blockingReason: value.blockingReason ?? null,
+  };
+}
+
+function assertBoolean(value, label) {
+  if (typeof value !== "boolean") throw new TypeError(`${label} must be a boolean`);
+}
+
+function workflowName(value) {
+  if (value === undefined) return "external-workflow";
+  if (typeof value !== "string" || value.trim() === "") {
+    throw new TypeError("workflowName must be a non-empty string");
+  }
+  return value;
+}
+
+function compatibleResult({ decision, name, autonomousMode, requiresUserApproval }) {
+  return {
+    status: "COMPATIBLE",
+    compatible: true,
+    autonomousMode,
+    workflowName: name,
+    forgeLoopClassification: decision.classification,
+    requiresUserApproval,
+    questionSource: null,
+    canAskUser: false,
+    requiresUserDecision: false,
+    recordAs: null,
+    addsUnresolvedDecision: false,
+    reasonCodes: [],
+  };
+}
+
+/**
+ * Evaluates an external workflow policy after ForgeLoop classifies the decision.
+ * The helper records a policy conflict instead of turning a reversible local
+ * default into a fake user blocker or mutating the decision classifier.
+ */
+export function classifyWorkflowCompatibility({
+  forgeLoopDecision,
+  workflowName: requestedWorkflowName,
+  requiresUserApproval = false,
+  autonomousMode,
+} = {}) {
+  assertBoolean(autonomousMode, "autonomousMode");
+  assertBoolean(requiresUserApproval, "requiresUserApproval");
+
+  const decision = normalizeDecision(forgeLoopDecision);
+  const name = workflowName(requestedWorkflowName);
+
+  if (!requiresUserApproval) {
+    return compatibleResult({
+      decision,
+      name,
+      autonomousMode,
+      requiresUserApproval,
+    });
+  }
+
+  if (decision.classification === "NON_BLOCKING") {
+    if (!autonomousMode) {
+      return {
+        status: "INTERACTIVE_APPROVAL",
+        compatible: true,
+        autonomousMode,
+        workflowName: name,
+        forgeLoopClassification: decision.classification,
+        requiresUserApproval,
+        questionSource: "EXTERNAL_WORKFLOW_POLICY",
+        canAskUser: true,
+        requiresUserDecision: true,
+        recordAs: null,
+        addsUnresolvedDecision: true,
+        reasonCodes: [EXTERNAL_WORKFLOW_REASON_CODES.REQUIRES_USER_GATE],
+      };
+    }
+
+    return {
+      status: "WORKFLOW_CONFLICT",
+      compatible: false,
+      autonomousMode,
+      workflowName: name,
+      forgeLoopClassification: decision.classification,
+      requiresUserApproval,
+      questionSource: "EXTERNAL_WORKFLOW_POLICY",
+      canAskUser: false,
+      requiresUserDecision: false,
+      recordAs: "WORKFLOW_CONFLICT",
+      addsUnresolvedDecision: false,
+      reasonCodes: [
+        EXTERNAL_WORKFLOW_REASON_CODES.APPROVAL_CONFLICT,
+        EXTERNAL_WORKFLOW_REASON_CODES.BLOCKS_NON_BLOCKING,
+        EXTERNAL_WORKFLOW_REASON_CODES.REQUIRES_USER_GATE,
+      ],
+    };
+  }
+
+  const legitimateBlockingQuestion = canAskUser(decision);
+  return {
+    ...compatibleResult({
+      decision,
+      name,
+      autonomousMode,
+      requiresUserApproval,
+    }),
+    questionSource: legitimateBlockingQuestion ? "FORGELOOP_BLOCKING_DECISION" : null,
+    canAskUser: legitimateBlockingQuestion,
+    requiresUserDecision: legitimateBlockingQuestion,
+    addsUnresolvedDecision: legitimateBlockingQuestion,
+    reasonCodes: legitimateBlockingQuestion
+      ? [EXTERNAL_WORKFLOW_REASON_CODES.REQUIRES_USER_GATE]
+      : [],
+  };
+}