@cassiomc1/forgeloop 1.10.0 → 1.10.1

package/src/core/artifacts.js

@@ -5,7 +5,7 @@ import { assertSecretFree } from "./receipt.js";
 import { assertJsonBytes, assertJsonLimits } from "./json-safety.js";
 import { assertSchema, readSchema } from "./schema-validation.js";
 import { getPackageRoot } from "./templates.js";
-import { getActiveTaskTransaction, withTaskTransaction } from "./transaction.js";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 export const ARTIFACT_PATHS = Object.freeze({
   contract: ".forgeloop/current-contract.json",
@@ -76,7 +76,7 @@ export async function readJsonArtifact(
   }
 
   const artifactPath = ensureWithin(target, relativePath);
-  const transaction = getActiveTaskTransaction();
+  const transaction = (await getTaskTransaction(target));
   const stagedText = transaction ? await transaction.readText(relativePath) : null;
   if (stagedText === null && !(await fileExists(artifactPath))) {
     throw new ArtifactError(
@@ -124,7 +124,7 @@ export async function writeJsonArtifact(
   } catch (error) {
     throw artifactError("ARTIFACT_PATH_INVALID", relativePath, error);
   }
-  const activeTransaction = getActiveTaskTransaction();
+  const activeTransaction = (await getTaskTransaction(target));
   if (!activeTransaction && taskId && !dryRun) {
     return withTaskTransaction({ target, taskId, operation, packageRoot }, async () => (
       writeJsonArtifact(target, relativePath, value, schemaName, packageRoot, { dryRun, taskId, operation })

package/src/core/checks.js

@@ -134,36 +134,3 @@ export function assertCheckList(value, label = "checks", options = {}) {
   });
   return value;
 }
-
-function requiredChecksSatisfiedBy(checks, requiredValues, selector, { allowInferred = false } = {}) {
-  assertCheckList(checks);
-  if (!Array.isArray(requiredValues)) throw checkError("E_CHECK_INVALID", "required values must be an array");
-  const errors = [];
-  for (const value of requiredValues) {
-    const candidates = checks.filter((check) => selector(check) === value);
-    const check = candidates.find((candidate) => candidate.status === "passed"
-      && (allowInferred || candidate.evidenceKind === "OBSERVED"))
-      ?? candidates.find((candidate) => candidate.status === "passed")
-      ?? candidates[0];
-    if (!check) {
-      errors.push(checkError("E_EVIDENCE_REQUIRED", `Required check is missing: ${value}`, [value]));
-      continue;
-    }
-    if (check.status !== "passed") {
-      errors.push(checkError("E_EVIDENCE_REQUIRED", `Required check is not passed: ${value}`, [value]));
-      continue;
-    }
-    if (!allowInferred && check.evidenceKind !== "OBSERVED") {
-      errors.push(checkError("E_EVIDENCE_KIND_INVALID", `Required check must be observed: ${value}`, [value]));
-    }
-  }
-  return errors;
-}
-
-export function requiredChecksSatisfied(checks, requiredIds, options = {}) {
-  return requiredChecksSatisfiedBy(checks, requiredIds, (check) => check.id, options);
-}
-
-export function requiredChecksSatisfiedForRequirements(checks, requiredRequirements, options = {}) {
-  return requiredChecksSatisfiedBy(checks, requiredRequirements, (check) => check.requirement, options);
-}

package/src/core/completion.js

@@ -17,7 +17,7 @@ import { listActions } from "./actions.js";
 import { readConfig } from "./config.js";
 import { resolveResponsibilityStatus } from "./responsibility.js";
 import { createCodeManifest, readCodeManifest, validateCodeManifestBindings, writeCodeManifest } from "./code-manifest.js";
-import { getActiveTaskTransaction, withTaskTransaction } from "./transaction.js";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 import { validateStructuralQualityCheckProvenance } from "./structural-quality/service.js";
 
 async function attestationConfiguration(target, packageRoot, errors) {
@@ -856,7 +856,7 @@ async function runCompleteInternal({
 
 export async function runComplete(options = {}) {
   const taskId = options.taskId ?? null;
-  if (options.persist !== false && taskId && !getActiveTaskTransaction()) {
+  if (options.persist !== false && taskId && !(await getTaskTransaction(options.target))) {
     return withTaskTransaction({
       target: options.target,
       taskId,

package/src/core/events.js

@@ -11,7 +11,7 @@ import { PROTOCOL_VERSION } from "./protocol.js";
 import { isRecoverableCompletionEvidenceCode } from "./completion-recovery.js";
 
 import { taskArtifactPath } from "./task-paths.js";
-import { getActiveTaskTransaction, withTaskTransaction } from "./transaction.js";
+import { getTaskTransaction, withTaskTransaction } from "./transaction.js";
 
 import { assertDiagnosisDetails } from "./diagnosis-model.js";
 import {
@@ -311,7 +311,7 @@ export function buildProtocolEvent(input, { checkpoint } = {}) {
 }
 
 export async function previewProtocolEvent(target, input, packageRoot, options = {}) {
-  const activeTransaction = getActiveTaskTransaction();
+  const activeTransaction = (await getTaskTransaction(target));
   if (!activeTransaction) {
     return withTaskTransaction({
       target,
@@ -337,7 +337,7 @@ export async function readEvents(target, packageRoot, options = {}) {
   const relPath = options?.eventsPath ?? options?.relativePath ?? (options?.taskId ? taskArtifactPath(options.taskId, "events") : ARTIFACT_PATHS.events);
   await assertSafePath(target, relPath);
   const eventsPath = ensureWithin(target, relPath);
-  const transaction = getActiveTaskTransaction();
+  const transaction = (await getTaskTransaction(target));
   if (transaction) {
     const stagedText = await transaction.readText(relPath);
     if (stagedText !== null) return parseEventsText(stagedText, relPath, packageRoot);
@@ -355,7 +355,7 @@ export async function readEventTail(target, packageRoot, options = {}) {
   const relPath = options?.eventsPath ?? options?.relativePath ?? (options?.taskId ? taskArtifactPath(options.taskId, "events") : ARTIFACT_PATHS.events);
   await assertSafePath(target, relPath);
   const eventsPath = ensureWithin(target, relPath);
-  const transaction = getActiveTaskTransaction();
+  const transaction = (await getTaskTransaction(target));
   if (transaction) {
     const stagedText = await transaction.readText(relPath);
     if (stagedText !== null) {
@@ -411,7 +411,7 @@ async function parseEventsText(text, relPath, packageRoot) {
 }
 
 export async function appendProtocolEvent(target, input, packageRoot, options = {}) {
-  const activeTransaction = getActiveTaskTransaction();
+  const activeTransaction = (await getTaskTransaction(target));
   if (typeof input?.taskId !== "string" || !input.taskId) throw protocolError("E_EVENT_INVALID", "event taskId is required");
   if (typeof input?.event !== "string" || !input.event) throw protocolError("E_EVENT_INVALID", "event type is required");
   const relPath = options?.eventsPath ?? options?.relativePath ?? (options?.taskId ? taskArtifactPath(options.taskId, "events") : ARTIFACT_PATHS.events);

package/src/core/execution-profile.js

@@ -66,24 +66,37 @@ function contractCollections(contract) {
 
 function contractSignals(contract) {
   const collections = contractCollections(contract);
+  const obligations = [];
+  const types = new Set();
+  function collect(requirement) {
+    if (typeof requirement === "string") obligations.push(requirement);
+    else if (requirement && typeof requirement === "object") {
+      if (typeof requirement.text === "string") obligations.push(requirement.text);
+      types.add(requirement.type);
+      if (Array.isArray(requirement.requirements)) requirement.requirements.forEach(collect);
+    }
+  }
+  collections.successCriteria.forEach(collect);
+  if (Array.isArray(contract?.verification)) contract.verification.forEach(collect);
   const riskText = collections.risks.join(" ").toLowerCase();
+  // Constraints and stop conditions describe boundaries, not obligations.
+  // Declared route risks remain authoritative even when a constraint excludes
+  // an operation; do not try to interpret prose negation as authorization.
   const allText = [
     ...collections.deliverables,
-    ...collections.successCriteria,
-    ...collections.constraints,
-    ...collections.stopConditions,
+    ...obligations,
   ].join(" ").toLowerCase();
   const combinedText = `${riskText} ${allText}`;
   const signals = {
     secrets: /\bsecrets?\b|\bcredentials?\b|\bpasswords?\b|\bprivate keys?\b/.test(combinedText),
     personalData: /\bpersonal[- ]data\b|\bpii\b|\bsensitive data\b/.test(combinedText),
-    publication: /\bpublication\b|\bpublish(?:ing|ed)?\b|\bdeploy(?:ment|ed)?\b/.test(combinedText),
+    publication: types.has("PUBLICATION") || /\bpublication\b|\bpublish(?:ing|ed)?\b|\bdeploy(?:ment|ed)?\b/.test(combinedText),
     destructive: /\bdestructive\b|\birreversible\b|\bdrop database\b|\bdelete production\b/.test(combinedText),
     migration: /\bmigration\b|\bmigrate\b|\bschema change\b|\birreversible persistence\b/.test(combinedText),
     payment: /\bpayments?\b|\bcheckout\b|\bbilling\b/.test(combinedText),
     externalMutation: /\bexternal mutation\b|\bmutate(?:s|d)? external\b|\bpublish(?:ing|ed)?\b/.test(combinedText),
     authoritySensitiveExternalMutation: /\bauthority[- ]sensitive\b|\bhost[- ]authorized external\b|\bexternal mutation requiring authority\b/.test(combinedText),
-    broadProductionValidation: /\bbroad production validation\b|\bproduction validation\b|\bvalidate in production\b/.test(combinedText),
+    broadProductionValidation: types.has("PRODUCTION_READINESS") || /\bbroad production validation\b|\bproduction validation\b|\bvalidate in production\b/.test(combinedText),
   };
   return signals;
 }

package/src/core/next-action-pending-actions.js

@@ -0,0 +1,255 @@
+import { taskArtifactPath } from "./task-paths.js";
+import { NEXT_ACTIONS, result } from "./next-action-model.js";
+import { artifactError } from "./next-action-artifacts.js";
+import { listActions } from "./actions.js";
+import { listApprovals } from "./approvals.js";
+import { loadPolicyIdentity } from "./policy-engine.js";
+
+export async function resolvePendingActionGuidance({ target, packageRoot, state, context, eventsRel, authorityContext, runtimeContext, helpers }) {
+  const {
+    capabilityDecisionMetadata,
+    actionApprovalGuidance,
+    actionAuthorityGuidance,
+    actionApprovalResolutionGuidance,
+    actionDeniedGuidance,
+    actionPolicyEpochGuidance,
+    authorizeActionGuidance,
+    evaluateProposedActionCapability,
+    findApplicablePendingApproval,
+  } = helpers;
+  let actionsForApproval;
+  try {
+    actionsForApproval = await listActions(target, { packageRoot, taskId: state.taskId });
+  } catch (error) {
+    if (error.code === "E_ACTION_INVALID") {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+        commands: [],
+        reasons: [artifactError(
+          error.code,
+          `A durable action artifact is invalid and cannot be offered for authorization: ${error.message}`,
+          [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        )],
+        requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+      });
+    }
+    throw error;
+  }
+  const ambiguousAction = actionsForApproval.find((action) => action.state === "COMMIT_UNKNOWN");
+  if (ambiguousAction) {
+    return result({ ...context, nextAction: NEXT_ACTIONS.RECONCILE_ACTION,
+      commands: [`forgeloop action-reconcile --task ${state.taskId} --action ${ambiguousAction.actionId} --outcome UNKNOWN`],
+      reasons: [artifactError("E_ACTION_RECONCILIATION_REQUIRED",
+        `Action ${ambiguousAction.actionId} has an unknown external commit outcome; retry is forbidden until reconciliation.`)],
+      reconciliationAuthorityRequired: {
+        outcomesRequiringTrust: ["COMMITTED", "NOT_COMMITTED"],
+        reason: "Recording an UNKNOWN observation is safe from any surface; settling COMMITTED or NOT_COMMITTED requires a trusted host boundary and evidence.",
+      },
+      requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel] });
+  }
+  // A PROPOSED required action ready for authorization should use the
+  // canonical authorization surface; host/approval blockers remain structured.
+  const authorizableAction = actionsForApproval.find((action) => action.requiredForCompletion
+    && action.state === "PROPOSED");
+  if (authorizableAction) {
+    let policyIdentity;
+    try {
+      policyIdentity = await loadPolicyIdentity(target, packageRoot, state.taskId);
+    } catch (error) {
+      return actionPolicyEpochGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        policyIdentity: {
+          code: error.code ?? "E_POLICY_INVALID",
+          message: `Capability policy epoch validation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+        },
+        eventsRel,
+      });
+    }
+    if (policyIdentity.status !== "VALID") {
+      return actionPolicyEpochGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        policyIdentity,
+        eventsRel,
+      });
+    }
+
+    let capability;
+    try {
+      capability = await evaluateProposedActionCapability({
+        target,
+        packageRoot,
+        action: authorizableAction,
+        authorityContext,
+      });
+    } catch (error) {
+      return result({
+        ...context,
+        nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+        commands: [],
+        reasons: [artifactError(
+          error.code ?? "E_ACTION_CAPABILITY_INVALID",
+          `Capability policy evaluation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+          [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        )],
+        capabilityDecision: {
+          capability: authorizableAction.capability,
+          decision: "DENY",
+          reasonCode: error.code ?? "E_ACTION_CAPABILITY_INVALID",
+          policyFingerprint: null,
+        },
+        requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+      });
+    }
+    if (capability.decision === "REQUIRE_AUTHORITY") {
+      return actionAuthorityGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    if (capability.allowed) {
+      return authorizeActionGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    if (capability.decision === "REQUIRE_APPROVAL") {
+      let approvals;
+      try {
+        approvals = await listApprovals(target, { packageRoot, taskId: state.taskId });
+      } catch (error) {
+        return result({
+          ...context,
+          nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+          commands: [],
+          reasons: [artifactError(
+            error.code ?? "E_APPROVAL_INVALID",
+            `Approval artifact inspection failed for required action ${authorizableAction.actionId}: ${error.message}`,
+            [taskArtifactPath(state.taskId, "approvals"), eventsRel],
+          )],
+          capabilityDecision: capabilityDecisionMetadata(authorizableAction, capability),
+          requiredArtifacts: [taskArtifactPath(state.taskId, "approvals"), eventsRel],
+        });
+      }
+      try {
+        capability = await evaluateProposedActionCapability({
+          target,
+          packageRoot,
+          action: authorizableAction,
+          approvals,
+          authorityContext,
+        });
+      } catch (error) {
+        return result({
+          ...context,
+          nextAction: NEXT_ACTIONS.RESOLVE_BLOCKER,
+          commands: [],
+          reasons: [artifactError(
+            error.code ?? "E_ACTION_CAPABILITY_INVALID",
+            `Capability policy evaluation failed for required action ${authorizableAction.actionId}: ${error.message}`,
+            [taskArtifactPath(state.taskId, "actions"), eventsRel],
+          )],
+          capabilityDecision: {
+            capability: authorizableAction.capability,
+            decision: "DENY",
+            reasonCode: error.code ?? "E_ACTION_CAPABILITY_INVALID",
+            policyFingerprint: null,
+          },
+          requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel],
+        });
+      }
+      if (capability.allowed) {
+        return authorizeActionGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          capability,
+          eventsRel,
+        });
+      }
+      if (capability.decision !== "REQUIRE_APPROVAL") {
+        if (capability.decision === "REQUIRE_AUTHORITY") {
+          return actionAuthorityGuidance({
+            context,
+            state,
+            action: authorizableAction,
+            capability,
+            eventsRel,
+          });
+        }
+        if (capability.allowed) {
+          return authorizeActionGuidance({
+            context,
+            state,
+            action: authorizableAction,
+            capability,
+            eventsRel,
+          });
+        }
+        return actionDeniedGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          capability,
+          eventsRel,
+        });
+      }
+      const pendingApproval = await findApplicablePendingApproval({
+        target,
+        packageRoot,
+        taskId: state.taskId,
+        action: authorizableAction,
+        approvals,
+      });
+      if (pendingApproval) {
+        return actionApprovalResolutionGuidance({
+          context,
+          state,
+          action: authorizableAction,
+          approval: pendingApproval,
+          eventsRel,
+        });
+      }
+      return actionApprovalGuidance({
+        context,
+        state,
+        action: authorizableAction,
+        capability,
+        eventsRel,
+      });
+    }
+    return actionDeniedGuidance({
+      context,
+      state,
+      action: authorizableAction,
+      capability,
+      eventsRel,
+    });
+  }
+  // Committed-but-unverified required action needs canonical postcondition
+  // evidence before it can satisfy completion.
+  const committedActions = actionsForApproval;
+  const unverifiedRequired = committedActions.find((action) => action.requiredForCompletion
+    && action.state === "COMMITTED");
+  if (unverifiedRequired) {
+    return result({ ...context, nextAction: NEXT_ACTIONS.VERIFY_EXTERNAL_ACTION,
+      commands: [
+        `forgeloop run-check --task ${state.taskId} --id check-postcondition --requirement <requirement> -- <independent verification argv>`,
+        `forgeloop action-verify --task ${state.taskId} --action ${unverifiedRequired.actionId} --evidence <execution-ref>`,
+      ],
+      reasons: [artifactError("E_ACTION_VERIFICATION_REQUIRED",
+        `Committed action ${unverifiedRequired.actionId} requires independent canonical postcondition evidence; exit code 0 alone is not verification.`)],
+      requiredArtifacts: [taskArtifactPath(state.taskId, "actions"), eventsRel] });
+  }
+  return null;
+}