@moretea-labs/forge 1.6.0 → 1.7.1

package/src/runtime/workflow/schedules/work-continuation.ts

@@ -22,7 +22,7 @@ export type ContinuationControllerType = 'chatgpt' | 'codex' | 'claude' | 'grok'
 export type WorkScheduleMode = 'continuation' | 'browser_watch' | 'browser_keepalive';
 
 export interface WorkContinuationScheduleInput {
-  workId: string;
+  workId?: string;
   scheduleMode?: WorkScheduleMode;
   controllerType?: ContinuationControllerType;
   executable?: string;
@@ -106,8 +106,9 @@ function normalizedTrigger(input: WorkContinuationScheduleInput): ScheduleTrigge
 }
 
 function wakeArguments(input: WorkContinuationScheduleInput, controllerType: ContinuationControllerType): Record<string, unknown> {
+  const workId = input.workId?.trim();
   return {
-    work_id: input.workId.trim(),
+    ...(workId ? { work_id: workId } : {}),
     controller_type: controllerType,
     ...(input.executable?.trim() ? { executable: input.executable.trim() } : {}),
     ...(input.launchArgs ? { launch_args: input.launchArgs.map(String) } : {}),
@@ -146,10 +147,13 @@ export function createWorkContinuationSchedule(
   controllerHome: string,
   repoId: string,
   input: WorkContinuationScheduleInput,
-): { schedule: RepositorySchedule; work: WorkContract } {
-  const work = activeWork(controllerHome, repoId, input.workId);
+): { schedule: RepositorySchedule; work?: WorkContract } {
   const controllerType = input.controllerType ?? 'chatgpt';
   const scheduleMode = input.scheduleMode ?? 'continuation';
+  const requestedWorkId = input.workId?.trim();
+  if (!requestedWorkId && scheduleMode !== 'browser_keepalive') throw new Error('WORK_ID_REQUIRED');
+  if (!requestedWorkId && scheduleMode === 'browser_keepalive' && controllerType !== 'chatgpt') throw new Error('STANDALONE_BROWSER_KEEPALIVE_CHATGPT_REQUIRED');
+  const work = requestedWorkId ? activeWork(controllerHome, repoId, requestedWorkId) : undefined;
   const trigger = normalizedTrigger(input);
   const operation = scheduleMode === 'continuation' ? 'external_controller_wake' : 'browser_probe';
   const actionArguments = scheduleMode === 'continuation'
@@ -157,9 +161,10 @@ export function createWorkContinuationSchedule(
     : probeArguments(input, controllerType, scheduleMode === 'browser_keepalive');
   assertAutomatedOperationAllowed(operation, actionArguments);
   const name = input.scheduleName?.trim()
-    || (scheduleMode === 'browser_watch' ? `Watch external state for Work ${work.workId}`
-      : scheduleMode === 'browser_keepalive' ? `Keep browser session alive for Work ${work.workId}`
-        : `Continue Work ${work.workId}`);
+    || (scheduleMode === 'browser_watch' ? `Watch external state for Work ${work!.workId}`
+      : scheduleMode === 'browser_keepalive'
+        ? (work ? `Keep browser session alive for Work ${work.workId}` : 'Keep browser session alive')
+        : `Continue Work ${work!.workId}`);
   const policy = {
     maxActiveOccurrences: 1,
     maxFailures: input.maxFailures !== undefined ? Math.max(1, Math.trunc(input.maxFailures)) : 3,
@@ -169,7 +174,7 @@ export function createWorkContinuationSchedule(
     backoffBaseMinutes: input.backoffBaseMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffBaseMinutes)) : 5,
     backoffMaxMinutes: input.backoffMaxMinutes !== undefined ? Math.max(1, Math.trunc(input.backoffMaxMinutes)) : 24 * 60,
   };
-  const stopConditions = input.stopConditions ?? ['work_terminal', 'human_review_required', 'external_blocker'];
+  const stopConditions = input.stopConditions ?? (work ? ['work_terminal', 'human_review_required', 'external_blocker'] : []);
 
   // A durable Work has one authoritative continuation lane. Changing cadence,
   // prompt, controller, or policy updates that lane instead of minting another
@@ -178,7 +183,7 @@ export function createWorkContinuationSchedule(
   if (scheduleMode === 'continuation') {
     const existing = listSchedules(controllerHome, repoId)
       .filter((candidate) => candidate.action.operation === 'external_controller_wake')
-      .filter((candidate) => candidate.action.arguments?.work_id === work.workId);
+      .filter((candidate) => candidate.action.arguments?.work_id === work!.workId);
     const authoritative = [...existing].reverse().find((candidate) => candidate.enabled) ?? existing.at(-1);
     if (authoritative) {
       const schedule = saveSchedule(controllerHome, {
@@ -196,7 +201,7 @@ export function createWorkContinuationSchedule(
         saveSchedule(controllerHome, {
           ...duplicate,
           enabled: false,
-          pausedReason: `Superseded by authoritative continuation ${schedule.scheduleId} for Work ${work.workId}.`,
+          pausedReason: `Superseded by authoritative continuation ${schedule.scheduleId} for Work ${work!.workId}.`,
         });
       }
       return { schedule, work };
@@ -205,7 +210,7 @@ export function createWorkContinuationSchedule(
 
   const semantic = JSON.stringify({
     repoId,
-    workId: work.workId,
+    workId: work?.workId,
     controllerType,
     scheduleMode,
     trigger,
@@ -215,7 +220,9 @@ export function createWorkContinuationSchedule(
     stopConditions,
   });
   const requestId = input.requestId?.trim()
-    || `work-continuation:${repoId}:${work.workId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`;
+    || (work
+      ? `work-continuation:${repoId}:${work.workId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`
+      : `browser-keepalive:${repoId}:${createHash('sha256').update(semantic).digest('hex').slice(0, 16)}`);
   const schedule = createSchedule(controllerHome, {
     requestId,
     repoId,
@@ -277,7 +284,13 @@ export function resumeWorkContinuationSchedule(controllerHome: string, repoId: s
   const schedule = continuationSchedule(getSchedule(controllerHome, repoId, scheduleId));
   const workId = typeof schedule.action.arguments?.work_id === 'string' ? schedule.action.arguments.work_id : '';
   activeWork(controllerHome, repoId, workId);
-  return saveSchedule(controllerHome, { ...schedule, enabled: true, pausedReason: undefined });
+  return saveSchedule(controllerHome, {
+    ...schedule,
+    enabled: true,
+    pausedReason: undefined,
+    consecutiveFailures: 0,
+    nextEligibleAt: undefined,
+  });
 }
 
 export async function triggerWorkContinuationSchedule(

package/src/testing/test-governance.ts

@@ -26,30 +26,24 @@ export type TestModule = (typeof TEST_MODULES)[number];
 export type TestResource = (typeof TEST_RESOURCES)[number];
 export type TestGate = 'affected' | 'core' | 'integration' | 'infrastructure' | 'fault' | 'full';
 
+/**
+ * Acceptance evidence is the default. Tests must protect externally observable
+ * contracts, migrations/rollback, failure injection, security boundaries, or
+ * a recorded production incident. Do not add tests for private helpers,
+ * implementation payloads, copy, enum order, or mock-only lifecycles.
+ */
+export const TEST_GOVERNANCE_POLICY = 'acceptance-first-no-internal-unit-tests' as const;
+
 export interface TestManifestEntry {
   module: TestModule;
   resource: TestResource;
   smoke?: boolean;
 }
 
-export interface TestBudgetPolicy {
-  maxTestFiles: number;
-  maxTestLines: number;
-  maxPureFiles: number;
-  maxTempIsolatedFiles: number;
-  maxProcessTreeFiles: number;
-  maxGitWorktreeFiles: number;
-  maxFixedPortFiles: number;
-  maxRuntimeSingletonFiles: number;
-  maxControllerHomeIsolatedFiles: number;
-  maxDestructiveFiles: number;
-}
-
 export interface TestManifest {
   version: 1;
   modules: TestModule[];
   resources: TestResource[];
-  policy: TestBudgetPolicy;
   pathModuleRules: Array<{ prefix: string; modules: TestModule[] }>;
   tests: Record<string, TestManifestEntry>;
 }
@@ -232,32 +226,6 @@ export function validateTestManifest(repoRoot: string, manifest = loadTestManife
     if (!TEST_RESOURCES.includes(entry.resource)) errors.push(`${file}: invalid resource ${String(entry.resource)}`);
   }
   if (!Object.values(manifest.tests).some((entry) => entry.smoke)) errors.push('manifest has no core smoke tests');
-  const resourceCounts = Object.values(manifest.tests).reduce<Record<string, number>>((counts, entry) => {
-    counts[entry.resource] = (counts[entry.resource] ?? 0) + 1;
-    return counts;
-  }, {});
-  const testLines = declaredFiles.reduce((total, file) => {
-    try {
-      return total + readFileSync(resolve(repoRoot, file), 'utf8').split('\n').length;
-    } catch (_error) {
-      return total;
-    }
-  }, 0);
-  const budgetChecks: Array<[string, number, number | undefined]> = [
-    ['maxTestFiles', declaredFiles.length, manifest.policy?.maxTestFiles],
-    ['maxTestLines', testLines, manifest.policy?.maxTestLines],
-    ['maxPureFiles', resourceCounts.pure ?? 0, manifest.policy?.maxPureFiles],
-    ['maxTempIsolatedFiles', resourceCounts['temp-isolated'] ?? 0, manifest.policy?.maxTempIsolatedFiles],
-    ['maxProcessTreeFiles', resourceCounts['process-tree'] ?? 0, manifest.policy?.maxProcessTreeFiles],
-    ['maxGitWorktreeFiles', resourceCounts['git-worktree'] ?? 0, manifest.policy?.maxGitWorktreeFiles],
-    ['maxFixedPortFiles', resourceCounts['fixed-port'] ?? 0, manifest.policy?.maxFixedPortFiles],
-    ['maxRuntimeSingletonFiles', resourceCounts['runtime-singleton'] ?? 0, manifest.policy?.maxRuntimeSingletonFiles],
-    ['maxControllerHomeIsolatedFiles', resourceCounts['controller-home-isolated'] ?? 0, manifest.policy?.maxControllerHomeIsolatedFiles],
-    ['maxDestructiveFiles', resourceCounts.destructive ?? 0, manifest.policy?.maxDestructiveFiles],
-  ];
-  for (const [name, actual, limit] of budgetChecks) {
-    if (typeof limit !== 'number' || actual > limit) errors.push(`test budget ${name} exceeded: ${actual} > ${String(limit)}`);
-  }
   return errors;
 }
 

package/assets/reference-configs/heartbeat-triage.md

@@ -1,57 +0,0 @@
-# Heartbeat Triage
-
-Heartbeat triage is the repo-local scheduled discovery loop. It records findings
-for a human to review; it does not approve plans, execute fixes, spawn agents,
-open PRs, or install a persistent scheduler.
-
-## Command
-
-Run from the repository root:
-
-```bash
-bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled
-```
-
-The command appends a run section to `.ai/harness/triage/inbox.md` and writes a
-JSON snapshot under `.ai/harness/runs/`. Each run records:
-
-- `workflow-check`: `bash .ai/harness/scripts/check-task-workflow.sh --strict`
-- `sprint-next`: `bash .ai/harness/scripts/sprint-backlog.sh next` when an active sprint
-  marker exists, with a read-only sprint-file fallback when it does not
-- `drift-requests`: pending files under `docs/architecture/requests/`
-
-## cron
-
-Example cron entry for a local checkout:
-
-```cron
-17 8 * * * cd /path/to/repo && bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled >/tmp/forge-heartbeat.log 2>&1
-```
-
-## loop
-
-Example long-running loop for a supervised terminal, launch wrapper, or local
-process manager:
-
-```bash
-while true; do
-  cd /path/to/repo && bash .ai/harness/scripts/heartbeat-triage.sh run --source scheduled
-  sleep 86400
-done
-```
-
-## Adoption Review
-
-Every run includes an "Adoption review due" date fourteen days out. The review
-question is narrow: did the inbox produce any human-accepted triage item? If no
-item is accepted during the review window, remove the scheduler and keep the
-runner as an on-demand diagnostic command.
-
-## Guardrails
-
-- Keep scheduler installation manual and host-local.
-- Treat workflow failures and drift requests as inbox entries, not process
-  crashes.
-- Keep `.ai/harness/triage/inbox.md` as runtime state, not a source-of-truth
-  plan or task ledger.
-- Keep execution authority in the normal plan -> contract -> verify flow.

package/assets/templates/helpers/harness-trace-grade.sh

@@ -1,150 +0,0 @@
-#!/bin/bash
-set -euo pipefail
-
-usage() {
-  cat <<'USAGE_EOF'
-Usage: scripts/harness-trace-grade.sh --run <trace.json> [--repo <repo>] [--strict]
-USAGE_EOF
-}
-
-run_file=""
-repo="."
-strict=0
-
-while [[ $# -gt 0 ]]; do
-  case "$1" in
-    --run)
-      run_file="${2:-}"
-      shift 2
-      ;;
-    --repo)
-      repo="${2:-.}"
-      shift 2
-      ;;
-    --strict)
-      strict=1
-      shift
-      ;;
-    --help|-h)
-      usage
-      exit 0
-      ;;
-    *)
-      echo "Unknown argument: $1" >&2
-      usage
-      exit 1
-      ;;
-  esac
-done
-
-[[ -n "$run_file" ]] || { usage >&2; exit 1; }
-[[ -f "$run_file" ]] || { echo "Trace run file not found: $run_file" >&2; exit 1; }
-command -v jq >/dev/null 2>&1 || { echo "jq is required for harness trace grading" >&2; exit 1; }
-
-if REPO_ROOT="$(cd "$repo" && pwd -P 2>/dev/null)"; then
-  :
-else
-  echo "Repo path not found: $repo" >&2
-  exit 1
-fi
-
-results_file="$(mktemp)"
-trap 'rm -f "$results_file"' EXIT
-: > "$results_file"
-
-record() {
-  local id="$1"
-  local passed="$2"
-  local message="$3"
-  jq -n \
-    --arg id "$id" \
-    --argjson passed "$passed" \
-    --arg message "$message" \
-    '{id: $id, passed: $passed, message: $message}' >> "$results_file"
-}
-
-trace_get() {
-  local query="$1"
-  jq -r "$query // empty" "$run_file"
-}
-
-schema="$(trace_get '.schema')"
-active_plan="$(trace_get '.active_plan')"
-task_profile="$(trace_get '.task_profile')"
-review_card_verdict="$(trace_get '.review.card.verdict')"
-review_card_change_type="$(trace_get '.review.card.change_type')"
-review_card_rollback="$(trace_get '.review.card.rollback')"
-commands_count="$(jq '.commands | if type == "array" then length else 0 end' "$run_file")"
-outside_count="$(jq '.allowed_paths_check.outside | if type == "array" then length else 0 end' "$run_file")"
-allowed_status="$(trace_get '.allowed_paths_check.status')"
-
-if [[ "$schema" == "forge-run-trace.v1" ]]; then
-  record "schema.v1" true "trace schema is forge-run-trace.v1"
-else
-  record "schema.v1" false "trace schema is ${schema:-missing}"
-fi
-
-if [[ -n "$active_plan" && -f "$REPO_ROOT/$active_plan" ]]; then
-  record "active_plan.resolves" true "active plan resolves: $active_plan"
-else
-  record "active_plan.resolves" false "active plan does not resolve: ${active_plan:-missing}"
-fi
-
-case "$task_profile" in
-  code-change|docs-only|ledger-closeout|migration|eval-only|delegated-run)
-    record "contract_profile.valid" true "contract profile is valid: $task_profile"
-    ;;
-  *)
-    record "contract_profile.valid" false "contract profile is invalid: ${task_profile:-missing}"
-    ;;
-esac
-
-if [[ "$review_card_verdict" == "pass" ]]; then
-  record "review_card.pass" true "Human Review Card verdict is pass"
-else
-  record "review_card.pass" false "Human Review Card verdict is ${review_card_verdict:-missing}"
-fi
-
-if [[ -n "$review_card_change_type" && "$review_card_change_type" == "$task_profile" ]]; then
-  record "review_card.change_type" true "Human Review Card change type matches task profile"
-else
-  record "review_card.change_type" false "Human Review Card change type ${review_card_change_type:-missing} does not match task profile ${task_profile:-missing}"
-fi
-
-rollback_token="$(printf '%s' "$review_card_rollback" | sed -E 's/[;,].*$//; s/[[:space:]].*$//; s/^[[:space:]]+//; s/[[:space:]]+$//' | tr '[:upper:]' '[:lower:]')"
-case "$rollback_token" in
-  ""|tbd|todo|n/a|na|none|unknown|unavailable|pending|...)
-    record "review_card.rollback" false "Human Review Card rollback is missing or not concrete"
-    ;;
-  *)
-    record "review_card.rollback" true "Human Review Card rollback is concrete"
-    ;;
-esac
-
-if [[ "$commands_count" -gt 0 ]] && jq -e '.commands[]? | select((.command // "") | length > 0)' "$run_file" >/dev/null; then
-  record "commands.present" true "commands evidence is present"
-else
-  record "commands.present" false "commands evidence is missing"
-fi
-
-if [[ "$outside_count" -eq 0 && "$allowed_status" == "pass" ]]; then
-  record "allowed_paths.clean" true "no changed file is outside allowed paths"
-else
-  record "allowed_paths.clean" false "allowed_paths status is ${allowed_status:-missing}; changed files outside allowed paths: $outside_count"
-fi
-
-failed="$(jq -s '[.[] | select(.passed == false)] | length' "$results_file")"
-total="$(jq -s 'length' "$results_file")"
-status="pass"
-[[ "$failed" -eq 0 ]] || status="fail"
-
-jq -s \
-  --arg status "$status" \
-  --arg run "$run_file" \
-  --argjson total "$total" \
-  --argjson failed "$failed" \
-  '{status: $status, run: $run, total: $total, failed: $failed, graders: .}' "$results_file"
-
-if [[ "$strict" -eq 1 && "$failed" -ne 0 ]]; then
-  exit 1
-fi