@arcfoundry/core 0.2.2 → 0.2.3

package/dist/agency-execution/contracted-stage-pipeline.js

@@ -2,6 +2,7 @@ import { executeContractedStage } from "./contracted-stage-execution.js";
 import { recordExecutedStageWave } from "./contracted-stage-recording.js";
 import { planStageExecutionWaves } from "./stage-dependency-plan.js";
 import { StageProgressRecorder } from "./stage-progress-recorder.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 export class ContractedOpenCodeStagePipeline {
     context;
     options;
@@ -13,6 +14,12 @@ export class ContractedOpenCodeStagePipeline {
     }
     async execute() {
         for (const wave of planStageExecutionWaves(this.context.workflowContract.stages)) {
+            for (const plannedStage of wave) {
+                reportWorkflowProgress(this.options.onProgress, {
+                    type: "stage-started",
+                    stage: plannedStage,
+                });
+            }
             const stageResults = await Promise.all(wave.map((plannedStage) => executeContractedStage({ context: this.context, options: this.options, plannedStage })));
             const failed = await recordExecutedStageWave({
                 context: this.context,

package/dist/agency-execution/contracted-stage-recording.js

@@ -1,5 +1,6 @@
 import { buildStageFailure } from "./contracted-stage-result.js";
 import { stageSucceeded } from "./stage-invocation.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 export async function recordExecutedStageWave(input) {
     for (const { stages } of input.stageResults) {
         for (const stage of stages)
@@ -8,6 +9,18 @@ export async function recordExecutedStageWave(input) {
     for (const { plannedStage, artifactStage } of input.stageResults) {
         if (stageSucceeded(artifactStage)) {
             await input.recorder.recordArtifact(plannedStage, artifactStage);
+            reportWorkflowProgress(input.options.onProgress, {
+                type: "stage-completed",
+                stage: plannedStage,
+                result: artifactStage,
+            });
+        }
+        else {
+            reportWorkflowProgress(input.options.onProgress, {
+                type: "stage-failed",
+                stage: plannedStage,
+                result: artifactStage,
+            });
         }
     }
     const failed = input.stageResults.find(({ artifactStage }) => !stageSucceeded(artifactStage));

package/dist/agency-execution/finalize.js

@@ -1,9 +1,15 @@
 import { writeAgentStageEvidence } from "./agent-stage-evidence.js";
 import { deliveryStatusFromCommands, resultFromContext } from "./delivery-readiness.js";
 import { commandFailureMessages, runFinalVerificationGates } from "./final-gates.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 import { writeSystemReport } from "./system-report.js";
 export async function finalizeAgencyExecution(context, options) {
-    context.commands.push(...(await runFinalVerificationGates(options.repoRoot, context.evidenceDir)));
+    reportWorkflowProgress(options.onProgress, { type: "final-gates-started" });
+    const finalCommands = await runFinalVerificationGates(options.repoRoot, context.evidenceDir);
+    for (const command of finalCommands) {
+        reportWorkflowProgress(options.onProgress, { type: "final-command-completed", command });
+    }
+    context.commands.push(...finalCommands);
     const status = deliveryStatusFromCommands(context.commands);
     const systemReport = await writeSystemReport(context.artifactDir, options, {
         gitBefore: context.gitBefore,
@@ -16,6 +22,7 @@ export async function finalizeAgencyExecution(context, options) {
     });
     context.artifacts.push(systemReport);
     await writeAgentStageEvidence(context);
+    reportWorkflowProgress(options.onProgress, { type: "completed", status });
     return resultFromContext(context, status);
 }
 export async function finalizeFailedAgencyExecution(context) {

package/dist/agency-execution/types.d.ts

@@ -1,10 +1,12 @@
 import { type ArtifactType, type CommandEvidence } from "@arcfoundry/schemas";
 import { type OpenCodeStageResult } from "../opencode-runtime/types.js";
+import { type WorkflowProgressReporter } from "../workflow-orchestration/progress.js";
 export type AgencyExecutionOptions = {
     repoRoot: string;
     projectId: string;
     requestId: string;
     clientRequest: string;
+    onProgress?: WorkflowProgressReporter;
 };
 export type AgencyExecutionResult = {
     runDir: string;

package/dist/local-request/delivery-pipeline.d.ts

@@ -4,6 +4,8 @@ import { type LocalDeliveryStatus } from "./delivery-readiness.js";
 export declare class LocalRequestDeliveryPipeline {
     private readonly context;
     private readonly options;
+    private reportedCommandCount;
     constructor(context: LocalRunContext, options: LocalAgencyExecutionOptions);
     execute(): Promise<LocalDeliveryStatus>;
+    private reportNewCommands;
 }

package/dist/local-request/delivery-pipeline.js

@@ -1,4 +1,5 @@
 import { writeRequestProject } from "./project-writer.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 import { localDeliveryCommands } from "./delivery-commands.js";
 import { localDeliveryReports } from "./delivery-reports.js";
 import { assessLocalDelivery } from "./delivery-readiness.js";
@@ -6,6 +7,7 @@ import { localWorkflowStages } from "./workflow-stages.js";
 export class LocalRequestDeliveryPipeline {
     context;
     options;
+    reportedCommandCount = 0;
     constructor(context, options) {
         this.context = context;
         this.options = options;
@@ -16,10 +18,14 @@ export class LocalRequestDeliveryPipeline {
         const implementation = await writeRequestProject(this.options.repoRoot, this.context.spec);
         await reports.writeImplementation(implementation);
         const commands = localDeliveryCommands(this.context);
+        reportWorkflowProgress(this.options.onProgress, { type: "final-gates-started" });
         const installPassed = await commands.runInstall();
+        this.reportNewCommands();
         const testsPassed = await commands.runTestAndBuild();
+        this.reportNewCommands();
         await reports.writeTest(testsPassed);
         const browserPassed = await commands.runBrowserValidation();
+        this.reportNewCommands();
         await reports.writeBrowserValidation({
             acceptanceCriteria,
             browserPassed,
@@ -30,4 +36,13 @@ export class LocalRequestDeliveryPipeline {
         await reports.writeSystemVerification(readiness.status);
         return readiness.status;
     }
+    reportNewCommands() {
+        for (const command of this.context.commands.slice(this.reportedCommandCount)) {
+            reportWorkflowProgress(this.options.onProgress, {
+                type: "final-command-completed",
+                command,
+            });
+        }
+        this.reportedCommandCount = this.context.commands.length;
+    }
 }

package/dist/local-request/stage-recorder.js

@@ -1,4 +1,5 @@
 import { ArtifactRunWriter } from "../artifacts/run-writer.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 import { writeLocalStageTranscript } from "./evidence.js";
 export class LocalStageRecorder {
     context;
@@ -8,6 +9,10 @@ export class LocalStageRecorder {
         this.options = options;
     }
     async recordStageAndArtifact(input) {
+        reportWorkflowProgress(this.options.onProgress, {
+            type: "stage-started",
+            stage: { stage: input.stageName, agent: input.agent },
+        });
         await writeLocalStageTranscript({
             stages: this.context.agentStages,
             transcriptDir: this.context.paths.transcriptDir,
@@ -17,6 +22,10 @@ export class LocalStageRecorder {
             output: input.output,
         });
         await this.writeArtifacts([this.stageArtifactSpec(input)]);
+        reportWorkflowProgress(this.options.onProgress, {
+            type: "stage-completed",
+            stage: { stage: input.stageName, agent: input.agent },
+        });
     }
     async recordStageArtifactSet(specs) {
         for (const spec of specs) {

package/dist/local-request/types.d.ts

@@ -1,10 +1,12 @@
 import { type AgentRole, type CommandEvidence } from "@arcfoundry/schemas";
+import { type WorkflowProgressReporter } from "../workflow-orchestration/progress.js";
 import { type LocalStageOutput } from "./stage-types.js";
 export type LocalAgencyExecutionOptions = {
     repoRoot: string;
     projectId: string;
     requestId: string;
     clientRequest: string;
+    onProgress?: WorkflowProgressReporter;
 };
 export type LocalAgentStage = {
     stage: string;

package/dist/local-request/workflow-phases.js

@@ -1,4 +1,5 @@
 import { writeAgentStageEvidence } from "./agent-stage-evidence.js";
+import { reportWorkflowProgress } from "../workflow-orchestration/progress.js";
 import { LocalRequestDeliveryPipeline } from "./delivery-pipeline.js";
 import { createLocalRunContext } from "./run-context.js";
 import { localWorkflowStages } from "./workflow-stages.js";
@@ -10,7 +11,9 @@ export class DefaultLocalWorkflowLifecycle {
         return createLocalRunContext(options);
     }
     async runConflictGate(context, options) {
+        reportWorkflowProgress(options.onProgress, { type: "adr-started" });
         await localWorkflowStages(context, options).writeConflictArtifacts();
+        reportWorkflowProgress(options.onProgress, { type: "adr-ready" });
         return context.conflicts.length > 0 ? "blocked" : "continue";
     }
     async executeDelivery(context, options) {

package/dist/local-request-workflow.js

@@ -1,4 +1,5 @@
 import { localAgencyExecutionResult } from "./local-request/execution-result.js";
+import { reportWorkflowProgress } from "./workflow-orchestration/progress.js";
 import { localWorkflowLifecycle, } from "./local-request/workflow-phases.js";
 import { GovernedWorkflow } from "./workflow-orchestration/governed-workflow.js";
 export class LocalAgencyWorkflow {
@@ -9,8 +10,16 @@ export class LocalAgencyWorkflow {
         this.lifecycle = dependencies.lifecycle ?? localWorkflowLifecycle();
     }
     async execute() {
-        return new GovernedWorkflow({
-            createContext: (options) => this.lifecycle.createContext(options),
+        reportWorkflowProgress(this.options.onProgress, { type: "context-started" });
+        const result = await new GovernedWorkflow({
+            createContext: async (options) => {
+                const context = await this.lifecycle.createContext(options);
+                reportWorkflowProgress(options.onProgress, {
+                    type: "context-ready",
+                    runDir: context.paths.runDir,
+                });
+                return context;
+            },
             evaluateGovernance: (context, options) => this.lifecycle.runConflictGate(context, options),
             executeDelivery: (context, options) => this.lifecycle.executeDelivery(context, options),
             finalizeDelivery: (context) => this.lifecycle.writeStageEvidence(context),
@@ -18,6 +27,8 @@ export class LocalAgencyWorkflow {
             deliveredStatus: (status) => status,
             result: localAgencyExecutionResult,
         }).execute(this.options);
+        reportWorkflowProgress(this.options.onProgress, { type: "completed", status: result.status });
+        return result;
     }
 }
 export async function runLocalAgencyExecution(options) {

package/dist/request-workflow.js

@@ -2,15 +2,24 @@ import { writeAdrRecord, writeConflictReportIfNeeded, } from "./agency-execution
 import { createAgencyExecutionContext } from "./agency-execution/execution-context.js";
 import { finalizeAgencyExecution, finalizeFailedAgencyExecution, } from "./agency-execution/finalize.js";
 import { runContractedOpenCodeStages } from "./agency-execution/stage-runner.js";
+import { reportWorkflowProgress } from "./workflow-orchestration/progress.js";
 export async function runAgencyExecution(options) {
+    reportWorkflowProgress(options.onProgress, { type: "context-started" });
     const context = await createAgencyExecutionContext(options);
+    reportWorkflowProgress(options.onProgress, { type: "context-ready", runDir: context.runDir });
+    reportWorkflowProgress(options.onProgress, { type: "adr-started" });
     await writeAdrRecord(context, options);
+    reportWorkflowProgress(options.onProgress, { type: "adr-ready" });
     if (await writeConflictReportIfNeeded(context, options)) {
-        return finalizeFailedAgencyExecution(context);
+        const result = await finalizeFailedAgencyExecution(context);
+        reportWorkflowProgress(options.onProgress, { type: "completed", status: result.status });
+        return result;
     }
     const stageRun = await runContractedOpenCodeStages(context, options);
     if (!stageRun.completed) {
-        return finalizeFailedAgencyExecution(context);
+        const result = await finalizeFailedAgencyExecution(context);
+        reportWorkflowProgress(options.onProgress, { type: "completed", status: result.status });
+        return result;
     }
     return finalizeAgencyExecution(context, options);
 }

package/dist/workflow-orchestration/progress.d.ts

@@ -0,0 +1,39 @@
+import { type AgentRole, type CommandEvidence } from "@arcfoundry/schemas";
+export type WorkflowProgressStage = {
+    stage: string;
+    agent: AgentRole;
+};
+export type WorkflowProgressStageResult = {
+    parsingError: string | null;
+};
+export type WorkflowProgressEvent = {
+    type: "context-started";
+} | {
+    type: "context-ready";
+    runDir: string;
+} | {
+    type: "adr-started";
+} | {
+    type: "adr-ready";
+} | {
+    type: "stage-started";
+    stage: WorkflowProgressStage;
+} | {
+    type: "stage-completed";
+    stage: WorkflowProgressStage;
+    result?: WorkflowProgressStageResult;
+} | {
+    type: "stage-failed";
+    stage: WorkflowProgressStage;
+    result: WorkflowProgressStageResult;
+} | {
+    type: "final-gates-started";
+} | {
+    type: "final-command-completed";
+    command: CommandEvidence;
+} | {
+    type: "completed";
+    status: "passed" | "failed";
+};
+export type WorkflowProgressReporter = (event: WorkflowProgressEvent) => void;
+export declare function reportWorkflowProgress(reporter: WorkflowProgressReporter | undefined, event: WorkflowProgressEvent): void;

package/dist/workflow-orchestration/progress.js

@@ -0,0 +1,3 @@
+export function reportWorkflowProgress(reporter, event) {
+    reporter?.(event);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcfoundry/core",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Core workflow, governance, artifact, and runtime primitives for Arc Foundry.",
   "license": "UNLICENSED",
   "files": [
@@ -19,7 +19,7 @@
   },
   "dependencies": {
     "@opencode-ai/sdk": "^1.15.11",
-    "@arcfoundry/schemas": "0.2.2"
+    "@arcfoundry/schemas": "0.2.3"
   },
   "engines": {
     "node": "^25.9.0"