@cassiomc1/forgeloop 0.1.3 → 0.1.4

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

@@ -27,3 +27,14 @@ load-bearing, irreversible, externally consequential, unsafe, or real
 user/business decisions.
 
 The loop and router are canonical sources; do not duplicate domain rules.
+
+## Pre-question decisions
+
+Before asking any product-detail question, classify it as `BLOCKING` or
+`NON_BLOCKING` using `LOOP_ENGINEERING.md`. For
+`NON_BLOCKING`, choose a safe reversible local default, record it in
+`current-contract.assumptions[]`, and continue. For `BLOCKING`, persist
+`current-contract.json` with `unresolvedDecisions[]` and a blocking reason
+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`.

package/.github/copilot-instructions.md

@@ -25,3 +25,14 @@ load-bearing, irreversible, externally consequential, unsafe, or real
 user/business decisions.
 
 The loop and router are canonical; do not replicate domain rules here.
+
+## Pre-question decisions
+
+Before asking any product-detail question, classify it as `BLOCKING` or
+`NON_BLOCKING` using `LOOP_ENGINEERING.md`. For
+`NON_BLOCKING`, choose a safe reversible local default, record it in
+`current-contract.assumptions[]`, and continue. For `BLOCKING`, persist
+`current-contract.json` with `unresolvedDecisions[]` and a blocking reason
+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`.

package/AGENTS.md

@@ -26,3 +26,14 @@ load-bearing, irreversible, externally consequential, unsafe, or real
 user/business decisions.
 
 The guides provide technical defaults; explicit requirements and project evidence prevail.
+
+## Pre-question decisions
+
+Before asking any product-detail question, classify it as `BLOCKING` or
+`NON_BLOCKING` using `LOOP_ENGINEERING.md`. For
+`NON_BLOCKING`, choose a safe reversible local default, record it in
+`current-contract.assumptions[]`, and continue. For `BLOCKING`, persist
+`current-contract.json` with `unresolvedDecisions[]` and a blocking reason
+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`.

package/CLAUDE.md

@@ -22,3 +22,14 @@ load-bearing, irreversible, externally consequential, unsafe, or real
 user/business decisions.
 
 Do not duplicate guide rules here; treat the loop and router as canonical sources.
+
+## Pre-question decisions
+
+Before asking any product-detail question, classify it as `BLOCKING` or
+`NON_BLOCKING` using `LOOP_ENGINEERING.md`. For
+`NON_BLOCKING`, choose a safe reversible local default, record it in
+`current-contract.assumptions[]`, and continue. For `BLOCKING`, persist
+`current-contract.json` with `unresolvedDecisions[]` and a blocking reason
+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`.

package/LOOP_ENGINEERING.md

@@ -7,31 +7,162 @@
 ## Blocking vs Non-Blocking Decisions
 
 Classify every unresolved decision before deciding whether to ask the user.
+The question is a consequence of a `BLOCKING` classification, never a default
+response to ordinary uncertainty.
 
-`NON_BLOCKING` applies when a safe local default exists, the choice is
-reversible, it does not change external state, it is not sensitive or
-authoritative, and it does not assert a real user or business fact. Examples
-include fictional company name, demo phone number, placeholder copy, temporary logo text,
-palette, typography, local-only fictional identity, fictional identity, demo
-contacts, visual defaults, section ordering, and local-only form behavior.
+### Pre-question decision classification
 
-`BLOCKING` applies when proceeding would require real legal business name,
-real contact details, credentials, payment data, production endpoint,
-deployment target, deployment or domain authority, destructive operation,
-irreversible architectural decision, irreversible data choice, regulated/legal claim,
-regulated claim, or another externally consequential/high-impact decision.
+Before asking the user any product-detail question:
+
+1. Classify the unresolved detail as `BLOCKING` or `NON_BLOCKING`.
+2. If `NON_BLOCKING`, do not ask; choose the smallest reasonable reversible
+   local default, record it in `current-contract.assumptions[]`, and continue.
+3. If `BLOCKING`, record the detail in
+   `current-contract.unresolvedDecisions[]`, persist and validate the contract,
+   then ask the user with a blocking reason.
+
+In short, `NON_BLOCKING` means do not ask and record it in `current-contract.assumptions[]`; `BLOCKING` means persist the contract and ask the user with a blocking reason.
+
+There is no third `UNKNOWN → ask` path for ordinary reversible product
+ambiguity. The invariant is:
+
+```text
+QUESTION
+must never happen
+before CLASSIFICATION
+```
+
+### PRE-QUESTION CHECK
+
+Before asking the user, answer every item:
+
+```text
+[ ] Is this a real user/business fact?
+[ ] Is this sensitive?
+[ ] Is this authoritative?
+[ ] Does it affect external state?
+[ ] Is it destructive?
+[ ] Is it irreversible?
+[ ] Would a safe local reversible default materially misrepresent the user?
+```
+
+If all answers are `NO`, classify the detail as `NON_BLOCKING`, record an
+assumption, and continue. If any answer is `YES`, classify it as `BLOCKING`,
+persist the contract before clarification, and attach a blocking reason.
 
 ### Safe assumption rule
 
-When a missing product detail is non-blocking, choose the smallest reasonable reversible default, explicitly classify it as an agent assumption, and record it in `current-contract.assumptions[]`. Each assumption must include `value`, `reason`, `scope`, `reversible=true`, and `source=agent-default`. Do not place resolved safe assumptions in unresolvedDecisions[]. Never present an assumption as a verified user or business fact.
+`NON_BLOCKING` applies when the choice is `SAFE + REVERSIBLE + LOCAL +
+NON-SENSITIVE + NON-AUTHORITATIVE + NON-DESTRUCTIVE` and does not assert a real
+user or business fact. Each recorded `ASSUMPTION` must include `value`, `reason`,
+`scope`, `reversible=true`, and `source=agent-default`. Do not place resolved
+safe assumptions in `unresolvedDecisions[]`, and never present an assumption as
+a verified user or business fact.
 
-The assumption boundary is:
+Generally `NON_BLOCKING` when no real business fact is supplied:
 
 ```text
-SAFE + REVERSIBLE + LOCAL + NON-SENSITIVE + NON-AUTHORITATIVE + NON-DESTRUCTIVE
+practice-area emphasis
+fictional positioning
+representative specialty mix
+tone of the fictional firm
+hero messaging
+section ordering
+fictional partner/attorney profiles
+fictional office location
+visual identity
+palette
+typography
+local fictional brand name
+local-only fictional identity
+fictional company name
+demo contact details
+demo phone number
+placeholder legal-service descriptions
+placeholder copy
+fictional testimonials
+temporary logo text
+local-only form behavior
+```
+
+These examples remain non-blocking only when they stay safe, reversible,
+local, non-sensitive, non-authoritative, and non-destructive. Do not hardcode
+one law-firm positioning into the protocol or tests.
+
+### Blocking boundary
+
+`BLOCKING` applies when proceeding requires any of the following:
+
+```text
+real legal business name
+real contact information
+real contact details
+real attorney identities
+credentials
+payment information
+payment data
+production endpoints
+production endpoint
+deployment target
+deployment/domain authority
+destructive operations
+destructive operation
+irreversible architecture
+irreversible architectural decision
+irreversible data decisions
+regulated or legal claims
+regulated/legal claim
+real compliance representations
+real business facts not safely inferable
+```
+
+Blocking decisions must be written to
+`current-contract.unresolvedDecisions[]`. They make `preflight` return
+`BLOCKED`, but they do not prevent contract serialization.
+Unresolved blocking decisions are recorded in `current-contract.unresolvedDecisions[]`.
+
+### Question justification invariant
+
+Asking the user is allowed only when `blockingReason` is present and comes from
+a blocking category such as:
+
+A user question requires a `blockingReason`; a question without one is invalid.
+
+```text
+REAL_BUSINESS_FACT_REQUIRED
+SENSITIVE_VALUE_REQUIRED
+EXTERNAL_AUTHORITY_REQUIRED
+IRREVERSIBLE_DECISION_REQUIRED
+REGULATED_CLAIM_REQUIRED
+DESTRUCTIVE_ACTION_REQUIRED
+```
+
+Multiple reasonable aesthetic or positioning choices do not justify a question.
+The deterministic support helper in `src/core/decision-classification.js`
+validates this boundary; it does not use an LLM or parse natural language.
+
+### Contract-before-clarification sequence
+
+The operational order is:
+
+```text
+DISCOVERY
+    ↓
+classify unresolved details
+    ↓
+create and persist current-contract.json
+    ↓
+persist assumptions[] and unresolvedDecisions[]
+    ↓
+validate contract
+    ↓
+if unresolvedDecisions.length > 0
+    ↓
+ask user with blockingReason
 ```
 
-Record the choice with an explicit `ASSUMPTION` marker. Unresolved blocking decisions must be recorded in `current-contract.unresolvedDecisions[]`; they prevent `preflight` from returning `READY` and block `EXECUTING` until resolved, but do not prevent contract serialization.
+No clarification stop is allowed before a serialized contract exists. A
+non-blocking ambiguity never becomes a contract blocker.
 
 ## Serialized protocol preparation
 

package/QUALITY_SCORECARD.md

@@ -17,7 +17,8 @@ policy are all present.
 | Completion enforcement | Canonical contract, persisted route, guide-declared gates, preflight, phase ledger, structured checks, evidence coverage, `audit`, `report`, and `complete` validators. |
 | 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 | Blocking vs Non-Blocking Decisions policy, explicit ASSUMPTION / source=agent-default recording, safe-boundary invariant, positive and negative tests, and a blind run showing non-blocking ambiguity continues while blocking ambiguity remains user-gated. |
+| 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. |
+| 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. |
 | Security boundaries | Realpath containment, bounded untrusted JSON, threat model, nested secret scanning, publication evidence, and explicit authority rules. |
@@ -37,14 +38,16 @@ policy are all present.
 - Literal graph runtime and runtime multi-agent orchestration are `N/A by
   design`; compatible harnesses own those capabilities.
 
-## Third-run conformance position
+## Blind-run conformance position
 
 | Dimension | Classification |
 | --- | --- |
-| Execution → Verification | REPRODUCED FAILURE before this fix |
-| Verification serialization | NOT_REACHED |
-| Review transition | NOT_REACHED |
-| Receipt generation | NOT_REACHED |
+| 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 |
+| 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 |
+| Receipt generation | NOT_REACHED in fourth blind run |
 | Full conformance | PARTIAL |
 
 ## Evidence matrix
@@ -63,7 +66,8 @@ 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 | `LOOP_ENGINEERING.md`, `CLAUDE.md`, `AGENTS.md`, `.github/copilot-instructions.md`, `.cursor/rules/project-loop.mdc`, and the blind conformance artifacts | `tests/autonomy-policy.test.js`, `tests/conformance-scenarios.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 |
 
 The implementation references above are local observations. OS runners,
 remote links, provider sessions, publication, and deployment remain `Not

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

@@ -0,0 +1,309 @@
+# ForgeLoop Fourth Blind Live Conformance Run
+
+This record documents the fourth blind live conformance experiment. The target
+was disposable and was not populated from the ForgeLoop working tree. The
+experiment used the published npm package and stopped when the blind agent
+asked a non-blocking product clarification question.
+
+## Environment
+
+- ForgeLoop release source commit: `99b56d7119098ce3637506f692c9d821e03eb8b1`
+- Approved merged `main` commit: `8d4296814ccc2d9a3d1aef3f6e7ad7219dfe0446`
+- Published-scope tree comparison: same between the release source commit and
+  approved merged `main`
+- ForgeLoop package version: `@cassiomc1/forgeloop@0.1.3`
+- npm tarball URL: `https://registry.npmjs.org/@cassiomc1/forgeloop/-/forgeloop-0.1.3.tgz`
+- Tarball SHA-1: `fb509e0da3f6f302c5342559f36c0e2c101fa6ce`
+- npm integrity SHA-512:
+  `sha512-iTrZ2UC5w5sSOQlSD61ACmVEsIdjzGUDZUaCohdmnIQ2NsfN60+tKHNxetAl6Gl7Dlq+QTHiPy8oocaSsOQ90Q==`
+- Agent: Codex CLI non-interactive agent
+- Model: not exposed by the harness
+- Harness: `codex-cli 0.146.0`, `codex exec`
+- Execution topology: `single-agent`
+- Agent process count: `1` primary process
+- Subagents enabled: `NO`
+- Delegation used: `NO`
+- Parallel agents: `NO`
+- Operating system: macOS `26.6.1` (`25G76`), `arm64`
+- Date/time: `2026-08-13T08:16:19-03:00` registration; agent started at
+  `2026-08-13T08:16:55-03:00`
+- Target path: `/Users/cassio/Documents/github/forgeloop-fourth-blind-live.DI06PF`
+- Conformance mode: Standard
+
+Installation procedure:
+
+1. Created the target as a new empty directory and confirmed zero entries.
+2. Fetched `@cassiomc1/forgeloop@0.1.3` from npm with `npm pack` outside the
+   target and verified the SHA-1 and SHA-512 values above.
+3. Installed the exact published package in a temporary external runtime with
+   `npm install --prefix <runtime> --no-save --ignore-scripts
+   @cassiomc1/forgeloop@0.1.3`.
+4. Confirmed the installed package and CLI both reported version `0.1.3`.
+5. Ran the installed CLI's normal initialization command:
+   `node <runtime>/node_modules/@cassiomc1/forgeloop/src/cli.js init --path <target>`.
+
+The initial `npx` binary form was rejected by npm 11 in this environment with
+`forgeloop: command not found`; this was diagnosed before the agent started.
+The external-runtime npm installation preserved the published package boundary
+and did not copy any ForgeLoop source checkout into the target.
+
+The agent received only this product request:
+
+```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, Loop Engineering, contract, routing, gate, preflight, lifecycle,
+verification, evidence, receipt, audit, completion, `forgeloop next`, or
+continuation instruction was added to the prompt.
+
+## Blind bootstrap and instruction discovery
+
+The initialized target contained the published adapter and canonical files,
+including `AGENTS.md`, `CLAUDE.md`, `.cursor/rules/project-loop.mdc`, and the
+shared loop documents. The blind agent's first observable message stated that
+it was using the project's required workflow and would inspect the local rules.
+Its first command read `LOOP_ENGINEERING.md`, `PROJECT_PROFILE.md`,
+`GUIDE_ROUTER.md`, and the available agent skill instructions. This is evidence
+of automatic instruction discovery without ForgeLoop coaching in the prompt.
+
+- Blind bootstrap: `PASS`
+- Instruction discovery: `PASS`
+- Protocol initialization before implementation: `NOT_REACHED`; no product
+  implementation began.
+
+## Pre-contract autonomy
+
+The agent asked:
+
+> What kind of law firm should the site represent?
+>
+> 1. Corporate and commercial law
+> 2. Litigation and dispute resolution
+> 3. Full-service private client firm
+
+It recommended corporate and commercial. The request did not require a real
+firm identity or legal-business fact, so this was a reversible, non-blocking
+choice. The agent did not select a local fictional identity autonomously and
+did not serialize an assumption in `current-contract.assumptions[]`.
+
+- Absence of real brand treated as non-blocking: `FAIL`
+- Fictional/local identity chosen without interruption: `FAIL`
+- Required assumption fields observed: `FAIL` — contract was never created
+- Reversible assumptions not presented as facts: `NOT_REACHED`
+- `unresolvedDecisions[]` empty for reversible choices: `NOT_REACHED`
+- Pre-contract autonomy: `FAIL`
+
+## Contract, routing and gates
+
+The target had no `.forgeloop/current-contract.json`,
+`.forgeloop/routing-result.json`, or `.forgeloop/gates/` after the agent
+stopped.
+
+- Contract creation: `FAIL`
+- Deterministic routing: `NOT_REACHED`
+- Gate enforcement: `NOT_REACHED`
+
+## Preflight chronology
+
+No `.forgeloop/preflight.json` or `.forgeloop/events.ndjson` was created. There
+was no `PREFLIGHT_READY`, `EXECUTION_STARTED`, task identity, or route identity
+to compare.
+
+- Preflight `READY`: `NOT_REACHED`
+- Blockers absent: `NOT_REACHED`
+- `PREFLIGHT_READY` before `EXECUTION_STARTED`: `NOT_REACHED`
+- Preflight chronology: `NOT_REACHED`
+
+## Implementation
+
+No product files were created. The target contains only the package-installed
+instruction, guide, schema, license, and manifest files. Therefore the
+premium, modern, sophisticated, trustworthy, responsive, and contact-form
+requirements were not exercised.
+
+- Implementation: `NOT_REACHED`
+- Product task outcome: `FAIL`
+
+## Lifecycle navigation
+
+The agent did not reach implementation and did not execute `forgeloop next`.
+The independent post-run `next` inspection reported:
+
+```json
+{
+  "currentPhase": "RECEIVED",
+  "nextAction": "DISCOVER",
+  "terminal": false,
+  "reasonCodes": ["WORK_STATE_ABSENT"]
+}
+```
+
+- Agent lifecycle navigation: `NOT_REACHED`
+- Execution → Verification handoff: `NOT_REACHED`
+- Expected `EXECUTING → forgeloop next → VERIFYING` sequence: `NOT_REACHED`
+- Implementation step reconciliation: `NOT_REACHED`
+
+## Receipt preparation
+
+The agent never reached `VERIFYING`, did not query `forgeloop next` in that
+phase, and did not run `prepare-completion`. No in-progress receipt or
+fingerprint set exists.
+
+- Receipt preparation: `NOT_REACHED`
+- Receipt generation: `NOT_REACHED`
+- Receipt treated as non-completion: `NOT_REACHED`
+- Receipt fingerprint consistency: `NOT_REACHED`
+
+## Real verification execution
+
+The agent executed no project tests, syntax checks, build, accessibility,
+security, performance, or visual checks. No check appears in a contract,
+receipt, or evidence ledger because none of those artifacts exists.
+
+- Verification execution: `NOT_REACHED`
+
+## Evidence chronology
+
+There was no `record-check`, no structured check, and no `VERIFICATION_RECORDED`
+event. Consequently, no result can be misclassified as observed evidence in
+this run, but the future-result behavior was not exercised.
+
+- Future-result fabrication prevention: `NOT_REACHED`
+- Evidence chronology: `NOT_REACHED`
+
+## Evidence serialization
+
+The target has no `work-state.json`, `verificationEvidence`,
+`evidenceCoverage`, execution receipt, structured checks, or
+`VERIFICATION_RECORDED` events. Required coverage was not produced.
+
+- Evidence serialization: `NOT_REACHED`
+- Evidence integrity: `NOT_REACHED`
+
+## Failure loop
+
+No project check ran and no verification failure entered the ForgeLoop failure
+loop. The observed failure was a pre-contract clarification stop.
+
+- Failure loop: `NOT_EXERCISED`
+
+## Review transition
+
+The agent did not reach verification or review, and no valid coverage existed
+that could authorize `ENTER_REVIEWING`.
+
+- Review transition: `NOT_REACHED`
+
+## Completion
+
+The agent did not reach `REVIEWING`, did not run `forgeloop next` for
+`RUN_COMPLETE`, and did not produce a validator-backed completion. The
+independent `complete --path <target> --json` command returned `REJECTED` with
+missing contract, route, receipt, and work-state artifacts.
+
+- Receipt generation: `NOT_REACHED`
+- Completion validation by the agent: `NOT_REACHED`
+- Lifecycle closure: `NOT_REACHED`
+
+## False-completion prevention
+
+The validator rejected completion rather than accepting an incomplete target.
+Observed rejection codes included `E_CONTRACT_MISSING`, `E_RECEIPT_MISSING`,
+`E_ROUTE_MISSING`, and `E_STATE_MISSING`. `validate-protocol` also returned
+`INVALID` with missing route, state, and receipt artifacts.
+
+- False-completion prevention: `PASS`
+
+## Chronology
+
+The persisted event ledger was absent, so the required protocol event sequence
+was never recorded.
+
+| Sequence | 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.3` |
+| Product implementation | No product files |
+
+Independent validator commands, all run against the disposable target using
+the installed `0.1.3` CLI:
+
+- `forgeloop next --path <target> --json`: exit `0`, `RECEIVED`,
+  `WORK_STATE_ABSENT`, next action `DISCOVER`.
+- `forgeloop audit --path <target> --json`: exit `1`, `INVALID`.
+- `forgeloop validate-protocol --path <target> --route-file
+  .forgeloop/routing-result.json --state-file .forgeloop/work-state.json
+  --receipt-file .forgeloop/execution-receipt.json --contract-file
+  .forgeloop/current-contract.json --json`: exit `1`, `INVALID`.
+- `forgeloop complete --path <target> --json`: exit `1`, `REJECTED`.
+
+No artifacts were edited manually to make the test pass.
+
+## Capability results
+
+| Capability | Result |
+| --- | --- |
+| Blind bootstrap | `PASS` |
+| Instruction discovery | `PASS` |
+| Pre-contract autonomy | `FAIL` |
+| Contract creation | `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` |
+| Receipt generation | `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 itself was already `PUBLISHED` as `0.1.3`.
+- Production readiness: `NOT_VERIFIED`
+
+## Final classification
+
+`PARTIAL`
+
+The run verified blind adapter bootstrap and instruction discovery and showed
+that the validators reject false completion. It did not reach protocol
+execution because the agent treated a reversible law-firm positioning choice as
+a blocking clarification instead of recording an agent-default assumption and
+continuing autonomously.

package/package.json

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

package/src/core/decision-classification.js

@@ -0,0 +1,55 @@
+export const BLOCKING_REASON_CODES = Object.freeze([
+  "REAL_BUSINESS_FACT_REQUIRED",
+  "SENSITIVE_VALUE_REQUIRED",
+  "EXTERNAL_AUTHORITY_REQUIRED",
+  "IRREVERSIBLE_DECISION_REQUIRED",
+  "REGULATED_CLAIM_REQUIRED",
+  "DESTRUCTIVE_ACTION_REQUIRED",
+]);
+
+const BLOCKING_RULES = Object.freeze([
+  ["realBusinessFact", "REAL_BUSINESS_FACT_REQUIRED"],
+  ["sensitive", "SENSITIVE_VALUE_REQUIRED"],
+  ["authoritative", "EXTERNAL_AUTHORITY_REQUIRED"],
+  ["external", "EXTERNAL_AUTHORITY_REQUIRED"],
+  ["irreversible", "IRREVERSIBLE_DECISION_REQUIRED"],
+  ["regulatedClaim", "REGULATED_CLAIM_REQUIRED"],
+  ["destructive", "DESTRUCTIVE_ACTION_REQUIRED"],
+]);
+
+function blockingDecision(reasonCode) {
+  return {
+    classification: "BLOCKING",
+    reasonCode,
+    blockingReason: reasonCode,
+  };
+}
+
+export function classifyDecision(flags = {}) {
+  if (!flags || typeof flags !== "object" || Array.isArray(flags)) {
+    return { classification: "NON_BLOCKING", reasonCode: "SAFE_REVERSIBLE_LOCAL_DEFAULT", blockingReason: null };
+  }
+
+  for (const [flag, reasonCode] of BLOCKING_RULES) {
+    if (flags[flag] === true) return blockingDecision(reasonCode);
+  }
+  if (flags.reversible === false || flags.local === false) {
+    return blockingDecision(
+      flags.reversible === false
+        ? "IRREVERSIBLE_DECISION_REQUIRED"
+        : "REAL_BUSINESS_FACT_REQUIRED",
+    );
+  }
+
+  return {
+    classification: "NON_BLOCKING",
+    reasonCode: "SAFE_REVERSIBLE_LOCAL_DEFAULT",
+    blockingReason: null,
+  };
+}
+
+export function canAskUser(decision) {
+  return decision?.classification === "BLOCKING"
+    && BLOCKING_REASON_CODES.includes(decision.reasonCode)
+    && decision.blockingReason === decision.reasonCode;
+}