forgeos 0.1.0-alpha.7 → 0.1.0-alpha.71

package/src/forge/agent-fabric/hardened-reducer.ts

@@ -0,0 +1,211 @@
+import { getOwn } from "./dictionary.ts";
+import { digestCanonical, sha256Digest } from "./canonical.ts";
+import { AgentFabricError } from "./errors.ts";
+import { replayControlState as replayLegacyControlState } from "./reducer.ts";
+import type {
+  AttemptExecutionPermit,
+  ControlEventEnvelope,
+  ControlState,
+  ReplayTrustContext,
+  WorkerResultReport,
+} from "./types.ts";
+
+function assertSingleRootExecution(events: readonly ControlEventEnvelope[]): void {
+  const rootExecutionId = events[0]?.rootExecutionId;
+  if (!rootExecutionId) return;
+  for (const event of events) {
+    if (event.rootExecutionId !== rootExecutionId) {
+      throw new AgentFabricError(
+        "AF_INVALID_EVENT",
+        `Control stream mixes root executions ${rootExecutionId} and ${event.rootExecutionId}`,
+      );
+    }
+  }
+}
+
+function assertStreamIdentityAndTemporalInvariants(
+  events: readonly ControlEventEnvelope[],
+): void {
+  const eventIds = new Set<string>();
+  const idempotencyKeys = new Set<string>();
+  const startupReportIds = new Set<string>();
+  const reportIds = new Set<string>();
+  const outcomeIds = new Set<string>();
+
+  for (const event of events) {
+    if (eventIds.has(event.eventId)) {
+      throw new AgentFabricError("AF_INVALID_EVENT", `Duplicate event ID ${event.eventId}`);
+    }
+    eventIds.add(event.eventId);
+
+    if (event.idempotencyKey !== undefined) {
+      if (idempotencyKeys.has(event.idempotencyKey)) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Duplicate idempotency key ${event.idempotencyKey}`,
+        );
+      }
+      idempotencyKeys.add(event.idempotencyKey);
+    }
+
+    if (event.payload.type === "owner_authorization_registered") {
+      const authorization = event.payload.authorization;
+      if (event.occurredAt < authorization.notBefore || event.occurredAt >= authorization.expiresAt) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Owner authorization ${authorization.authorizationId} was admitted outside its validity window`,
+        );
+      }
+    }
+
+    if (event.payload.type === "attempt_execution_permit_issued") {
+      if (event.payload.permit.notBefore !== event.occurredAt) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Permit ${event.payload.permit.permitId} admission time differs from event time`,
+        );
+      }
+    }
+
+    if (event.payload.type === "attempt_started") {
+      if (startupReportIds.has(event.payload.startupReportId)) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Startup report ID was reused: ${event.payload.startupReportId}`,
+        );
+      }
+      startupReportIds.add(event.payload.startupReportId);
+    }
+
+    if (event.payload.type === "attempt_outcome_committed") {
+      const outcome = event.payload.outcome;
+      if (outcomeIds.has(outcome.outcomeId)) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Outcome ID was reused: ${outcome.outcomeId}`,
+        );
+      }
+      outcomeIds.add(outcome.outcomeId);
+      if (reportIds.has(outcome.reportId)) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Worker report ID was reused: ${outcome.reportId}`,
+        );
+      }
+      reportIds.add(outcome.reportId);
+    }
+  }
+}
+
+function assertPermitGoalAuthorityBinding(
+  state: ControlState,
+  permit: AttemptExecutionPermit,
+): void {
+  const intent = getOwn(state.dispatchIntents, permit.intentId);
+  const revision = getOwn(state.planRevisions, permit.planRevisionId);
+  const grant = getOwn(state.grants, permit.grantId);
+  const goal = revision ? getOwn(state.goals, revision.goalId) : undefined;
+  const authorization = grant ? getOwn(state.authorizations, grant.rootAuthorizationId) : undefined;
+
+  if (!intent || !revision || !grant || !goal || !authorization) {
+    throw new AgentFabricError(
+      "AF_INVALID_EVENT",
+      `Permit ${permit.permitId} has incomplete goal/authority lineage`,
+    );
+  }
+
+  if (
+    intent.planRevisionId !== revision.revisionId ||
+    intent.rootExecutionId !== revision.rootExecutionId ||
+    authorization.rootExecutionId !== revision.rootExecutionId ||
+    goal.authorityInvocationId !== grant.rootAuthorizationId ||
+    !authorization.goalIds.includes(goal.goalId)
+  ) {
+    throw new AgentFabricError(
+      "AF_INVALID_EVENT",
+      `Permit ${permit.permitId} uses authority that is not bound to its GoalContract`,
+    );
+  }
+}
+
+function workerReportFromOutcome(
+  outcome: ControlState["outcomes"][string],
+): WorkerResultReport {
+  return {
+    reportId: outcome.reportId,
+    attemptId: outcome.attemptId,
+    permitId: outcome.permitId,
+    intentId: outcome.intentId,
+    planRevisionId: outcome.planRevisionId,
+    effectiveRunSpecDigest: outcome.effectiveRunSpecDigest,
+    fencingToken: outcome.fencingToken,
+    status: outcome.status,
+    resultDigest: outcome.resultDigest,
+    evidenceDigests: [...outcome.evidenceDigests],
+    reportedAt: outcome.reportedAt,
+  };
+}
+
+function assertReplayOnlyInvariants(
+  events: readonly ControlEventEnvelope[],
+  state: ControlState,
+): void {
+  const permitByAttemptId = new Map<string, string>();
+
+  for (const event of events) {
+    if (event.payload.type === "attempt_execution_permit_issued") {
+      const permit = event.payload.permit;
+      const existingPermitId = permitByAttemptId.get(permit.attemptId);
+      if (existingPermitId) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Attempt ${permit.attemptId} has multiple permits: ${existingPermitId}, ${permit.permitId}`,
+        );
+      }
+      permitByAttemptId.set(permit.attemptId, permit.permitId);
+      assertPermitGoalAuthorityBinding(state, permit);
+    }
+
+    if (event.payload.type === "attempt_outcome_committed") {
+      const outcome = event.payload.outcome;
+      const expectedReportDigest = digestCanonical(workerReportFromOutcome(outcome), sha256Digest);
+      if (outcome.reportDigest !== expectedReportDigest) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Outcome ${outcome.outcomeId} report digest does not match its persisted report fields`,
+        );
+      }
+      const permit = getOwn(state.permits, outcome.permitId);
+      if (!permit) {
+        throw new AgentFabricError(
+          "AF_INVALID_EVENT",
+          `Outcome ${outcome.outcomeId} references an unknown permit`,
+        );
+      }
+      assertPermitGoalAuthorityBinding(state, permit);
+    }
+  }
+}
+
+export function replayControlState(
+  events: readonly ControlEventEnvelope[],
+  trust: ReplayTrustContext,
+): ControlState {
+  try {
+    assertSingleRootExecution(events);
+    assertStreamIdentityAndTemporalInvariants(events);
+    const state = replayLegacyControlState(events, trust);
+    assertReplayOnlyInvariants(events, state);
+    return state;
+  } catch (error) {
+    if (error instanceof AgentFabricError) throw error;
+    throw new AgentFabricError(
+      "AF_INVALID_EVENT",
+      "Malformed control stream could not be replayed",
+      {
+        causeName: error instanceof Error ? error.name : typeof error,
+        causeMessage: error instanceof Error ? error.message : String(error),
+      },
+    );
+  }
+}

package/src/forge/agent-fabric/index.ts

@@ -0,0 +1,48 @@
+export * from "./adapter.ts";
+export * from "./authority.ts";
+export * from "./canonical.ts";
+export { ForgeAgentConductor } from "./hardened-conductor.ts";
+export type {
+  ClaimDispatchInput,
+  IssuePermitInput,
+} from "./hardened-conductor.ts";
+export * from "./errors.ts";
+export * from "./journal.ts";
+export { LocalEvolutionRegistry } from "./local-evolution-registry.ts";
+export type { ExtensionCandidate, ExtensionVersion, FixedEvaluationSuite, EvaluationRecord,
+  EvolutionChannel, EvolutionDecisionAction, EvolutionVersionStatus, EvolutionOwnerVerifier } from "./local-evolution-registry.ts";
+export { LocalEvolutionService, LOCAL_EVOLUTION_SUITE } from "./local-evolution-service.ts";
+export * from "./p0a.ts";
+export * from "./p0b-model-adapter.ts";
+export * from "./planning.ts";
+export { replayControlState } from "./hardened-reducer.ts";
+export { createEmptyControlState } from "./reducer.ts";
+export * from "./resource-ledger.ts";
+export * from "./validation.ts";
+export type * from "./types.ts";
+export { AttachedTaskService } from "./attached-task-service.ts";
+export { AttachedTaskStore } from "./attached-task-store.ts";
+export { captureAttachedSnapshot } from "./attached-snapshot.ts";
+export { attachedReadiness } from "./readiness.ts";
+export type { AttachedTaskState, AttachedSnapshot, AttachedAssignment, AttachedAttempt, AttachedReview } from "./attached-task-contract.ts";
+export {
+  createWorkflow, nextWorkflow, claimWorkflow, completeWorkflow,
+  reconcileWorkflow, replanWorkflow, recoverWorkflow, validateWorkflowState,
+} from "./workflow-engine.ts";
+export type { WorkflowState, WorkflowLimits, WorkflowResult, WorkflowPacket, WorkflowRun,
+  WorkflowNode as DynamicWorkflowNode } from "./workflow-engine.ts";
+export { createChangeReviewWorkflow, createInvestigationWorkflow } from "./workflow-templates.ts";
+export { ManagedRunService } from "./managed-run-service.ts";
+export { ManagedRunStore } from "./managed-run-store.ts";
+export { MANAGED_RUN_ACTIONS, ManagedRunError, validateManagedSpec } from "./managed-run-contract.ts";
+export type { ManagedRunState, ManagedRunSpec, ManagedExecutorSpec, ManagedEvent, ManagedStep } from "./managed-run-contract.ts";
+export { runCodexWorker, CodexWorkerError } from "./codex-sdk-worker.ts";
+export { prepareManagedEnvironment, verifyManagedEnvironment } from "./managed-environment.ts";
+export type { ManagedEnvironment, ManagedEnvironmentOptions } from "./managed-environment.ts";
+export * from "./program-contract.ts";
+export { lowerWorkflowSource, PROGRAM_DSL_VERSION } from "./program-dsl.ts";
+export { ProgramRunService, PROGRAM_RUN_ACTIONS } from "./program-service.ts";
+export type { ProgramRunAction } from "./program-service.ts";
+export { ProgramRunStore } from "./program-store.ts";
+export { validateProgramCapabilities } from "./program-worker.ts";
+export type { ProgramWorkerAdapter, ProgramWorkerInput, ProgramWorkerResult } from "./program-worker.ts";

package/src/forge/agent-fabric/journal.ts

@@ -0,0 +1,116 @@
+import { digestCanonical, sha256Digest, stableStringify } from "./canonical.ts";
+import { AgentFabricError } from "./errors.ts";
+import type { ControlEventEnvelope, Digest, Identifier, UncommittedControlEvent } from "./types.ts";
+import { validateControlEventEnvelope, validateUncommittedControlEvent } from "./validation.ts";
+
+export interface AppendControlEventInput {
+  expectedSequence: number;
+  event: UncommittedControlEvent;
+}
+
+export interface ControlJournal {
+  append(input: AppendControlEventInput): ControlEventEnvelope;
+  readAll(): readonly ControlEventEnvelope[];
+}
+
+function deepFreeze<T>(value: T): T {
+  if (value && typeof value === "object" && !Object.isFrozen(value)) {
+    Object.freeze(value);
+    for (const child of Object.values(value as Record<string, unknown>)) deepFreeze(child);
+  }
+  return value;
+}
+
+function eventDigestInput(envelope: Omit<ControlEventEnvelope, "eventDigest">): unknown {
+  return envelope;
+}
+
+function semanticFingerprint(event: UncommittedControlEvent): string {
+  return stableStringify({
+    eventId: event.eventId,
+    rootExecutionId: event.rootExecutionId,
+    idempotencyKey: event.idempotencyKey ?? null,
+    payload: event.payload,
+  });
+}
+
+export class MemoryControlJournal implements ControlJournal {
+  private readonly events: ControlEventEnvelope[] = [];
+  private readonly byEventId = new Map<Identifier, ControlEventEnvelope>();
+  private readonly byIdempotencyKey = new Map<Identifier, ControlEventEnvelope>();
+
+  append(input: AppendControlEventInput): ControlEventEnvelope {
+    validateUncommittedControlEvent(input.event);
+    const incoming = structuredClone(input.event);
+    const incomingFingerprint = semanticFingerprint(incoming);
+
+    const existingByIdempotency = incoming.idempotencyKey
+      ? this.byIdempotencyKey.get(incoming.idempotencyKey)
+      : undefined;
+    if (existingByIdempotency) {
+      if (incomingFingerprint !== semanticFingerprint(existingByIdempotency)) {
+        throw new AgentFabricError(
+          "AF_CONFLICT",
+          `Idempotency key ${incoming.idempotencyKey} was reused with different content`,
+        );
+      }
+      return structuredClone(existingByIdempotency);
+    }
+
+    const existingById = this.byEventId.get(incoming.eventId);
+    if (existingById) {
+      if (incomingFingerprint !== semanticFingerprint(existingById)) {
+        throw new AgentFabricError(
+          "AF_DUPLICATE_ID",
+          `Event ID ${incoming.eventId} was reused with different content`,
+        );
+      }
+      return structuredClone(existingById);
+    }
+
+    if (input.expectedSequence !== this.events.length) {
+      throw new AgentFabricError(
+        "AF_CONFLICT",
+        "Control journal compare-and-swap failed",
+        { actualSequence: this.events.length, expectedSequence: input.expectedSequence },
+      );
+    }
+
+    const predecessor = this.events[this.events.length - 1];
+    if (predecessor && incoming.occurredAt < predecessor.occurredAt) {
+      throw new AgentFabricError(
+        "AF_INVALID_EVENT",
+        "Control journal timestamps must be monotonic",
+        { occurredAt: incoming.occurredAt, predecessorOccurredAt: predecessor.occurredAt },
+      );
+    }
+
+    const withoutDigest: Omit<ControlEventEnvelope, "eventDigest"> = {
+      ...incoming,
+      sequence: this.events.length + 1,
+      predecessorEventId: predecessor?.eventId ?? null,
+      predecessorEventDigest: predecessor?.eventDigest ?? null,
+    };
+    const envelope: ControlEventEnvelope = {
+      ...withoutDigest,
+      eventDigest: digestCanonical(eventDigestInput(withoutDigest), sha256Digest),
+    };
+    validateControlEventEnvelope(envelope);
+
+    const stored = deepFreeze(structuredClone(envelope));
+    this.events.push(stored);
+    this.byEventId.set(stored.eventId, stored);
+    if (stored.idempotencyKey) this.byIdempotencyKey.set(stored.idempotencyKey, stored);
+    return structuredClone(stored);
+  }
+
+  readAll(): readonly ControlEventEnvelope[] {
+    return this.events.map((event) => structuredClone(event));
+  }
+}
+
+export function computeControlEventDigest(
+  envelope: Omit<ControlEventEnvelope, "eventDigest">,
+): Digest {
+  return digestCanonical(eventDigestInput(envelope), sha256Digest);
+}

package/src/forge/agent-fabric/local-adaptive-digest-worker.mjs

@@ -0,0 +1,26 @@
+// Fixed data-only worker. This file deliberately has no Forge imports, tools,
+// filesystem access, or network calls. The coordinator verifies its output.
+import { createHash } from "node:crypto";
+
+let input = "";
+process.stdin.setEncoding("utf8");
+process.stdin.on("data", (chunk) => {
+  input += chunk;
+  if (Buffer.byteLength(input, "utf8") > 1_024) process.exit(2);
+});
+process.stdin.on("end", () => {
+  try {
+    const message = JSON.parse(input);
+    if (!message || Object.keys(message).sort().join(",") !== "input,role" ||
+        !["inventory", "constraints"].includes(message.role) ||
+        typeof message.input !== "string" || message.input.length > 256) {
+      process.exitCode = 2;
+      return;
+    }
+    const canonical = JSON.stringify({ input: message.input, role: message.role });
+    const resultDigest = `sha256:${createHash("sha256").update(canonical).digest("hex")}`;
+    process.stdout.write(JSON.stringify({ pid: process.pid, role: message.role, resultDigest }));
+  } catch {
+    process.exitCode = 2;
+  }
+});