@moretea-labs/forge 1.5.0-rc.1

package/src/runtime/release/release-gate.ts

@@ -0,0 +1,137 @@
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { listAgentJobs, listPendingIntegrationRuns } from '../../cli/agent-jobs/job-manager';
+import { listIssues } from '../../cli/controller/issue-store';
+import { listEditSessions } from '../../cli/editing/edit-session';
+import { listLocalBridgeJobs } from '../../cli/local-bridge/job-store';
+import { validateRepository } from '../../cli/repositories/registry';
+import { readForgeRuntimeStatus } from '../control-plane/runtime-status-client';
+import { listActiveExecutionJobs } from '../execution/jobs/store';
+import type { ExecutionJob } from '../execution/jobs/types';
+import { listActiveLeases } from '../resources/leases/store';
+
+export interface ReleaseGateResult {
+  releaseReady: boolean;
+  checkedAt: string;
+  revision: string;
+  blockers: Array<{ code: string; message: string; entityId?: string }>;
+  warnings: Array<{ code: string; message: string }>;
+  checks: Record<string, boolean>;
+  manifest: {
+    repoId: string;
+    revision: string;
+    verifiedTaskIds: string[];
+    evidenceJobIds: string[];
+    packageName?: string;
+    packageVersion?: string;
+  };
+}
+
+function git(repoRoot: string, args: string[]): { ok: boolean; output: string; error: string } {
+  const result = spawnSync('git', ['-C', repoRoot, ...args], { encoding: 'utf8', timeout: 10_000, maxBuffer: 512 * 1024 });
+  return {
+    ok: result.status === 0 && !result.error,
+    output: typeof result.stdout === 'string' ? result.stdout.trim() : '',
+    error: [typeof result.stderr === 'string' ? result.stderr.trim() : '', result.error instanceof Error ? result.error.message : ''].filter(Boolean).join('\n'),
+  };
+}
+
+function packageMetadata(repoRoot: string): { valid: boolean; name?: string; version?: string } {
+  const path = join(repoRoot, 'package.json');
+  if (!existsSync(path)) return { valid: true };
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { name?: unknown; version?: unknown; bin?: unknown };
+    const name = typeof parsed.name === 'string' && parsed.name.trim() ? parsed.name.trim() : undefined;
+    const version = typeof parsed.version === 'string' && /^\d+\.\d+\.\d+(?:[-+].+)?$/.test(parsed.version) ? parsed.version : undefined;
+    return { valid: Boolean(name && version && parsed.bin), name, version };
+  } catch {
+    return { valid: false };
+  }
+}
+
+export function evaluateReleaseGate(controllerHome: string, repoRoot: string, job: ExecutionJob): ReleaseGateResult {
+  const blockers: ReleaseGateResult['blockers'] = [];
+  const warnings: ReleaseGateResult['warnings'] = [];
+  const head = git(repoRoot, ['rev-parse', '--verify', 'HEAD']);
+  const revision = head.output || 'unversioned';
+  const status = git(repoRoot, ['status', '--porcelain=v1']);
+  const activeJobs = listActiveExecutionJobs(controllerHome, job.repoId).filter((entry) => entry.jobId !== job.jobId);
+  const allAgentJobs = listAgentJobs(repoRoot, 5000);
+  const agentJobs = allAgentJobs.filter((entry) => ['queued', 'starting', 'running', 'waiting_for_user'].includes(entry.status));
+  const pendingIntegrations = listPendingIntegrationRuns(repoRoot, 5000);
+  const localJobs = listLocalBridgeJobs(repoRoot, 5000).filter((entry) => ['approved', 'running', 'dispatched'].includes(entry.status));
+  const editSessions = listEditSessions(repoRoot, 500).filter((entry) => !['finalized', 'rolled_back'].includes(entry.status));
+  const leases = listActiveLeases(controllerHome, job.repoId).filter((entry) => entry.ownerJobId !== job.jobId);
+  const repositoryValidation = validateRepository(job.repoId, controllerHome);
+  const daemon = readForgeRuntimeStatus(controllerHome);
+  const pkg = packageMetadata(repoRoot);
+  const issues = listIssues(repoRoot, { includeEphemeral: false });
+  const releaseRelevantIssues = issues.filter((issue) => ['planned', 'launch_blocked', 'in_progress', 'review'].includes(issue.status));
+  const unfinishedTasks = releaseRelevantIssues.flatMap((issue) => issue.tasks
+    .filter((task) => !['done', 'cancelled', 'superseded'].includes(task.status))
+    .map((task) => ({ issueId: issue.id, taskId: task.id, status: task.status })));
+  const completedTasks = issues.flatMap((issue) => issue.tasks
+    .filter((task) => ['verified', 'done'].includes(task.status))
+    .map((task) => ({ issueId: issue.id, task })));
+  const staleVerificationTasks = revision === 'unversioned' ? [] : completedTasks.filter(({ task }) => {
+    const boundRevision = task.verification?.integratedRevision;
+    return Boolean(boundRevision && boundRevision !== revision);
+  });
+  const missingVerificationTasks = completedTasks.filter(({ task }) => task.checks.length > 0 && !task.verification);
+
+  if (!head.ok) blockers.push({ code: 'REVISION_UNAVAILABLE', message: head.error || 'Unable to resolve repository HEAD.' });
+  if (!status.ok) blockers.push({ code: 'GIT_STATUS_FAILED', message: status.error || 'Unable to read repository status.' });
+  else if (status.output) blockers.push({ code: 'WORKSPACE_DIRTY', message: 'Repository workspace is not clean.' });
+  if (activeJobs.length) blockers.push({ code: 'ACTIVE_EXECUTION_JOBS', message: `${activeJobs.length} execution jobs are still active.` });
+  if (agentJobs.length) blockers.push({ code: 'ACTIVE_AGENT_RUNS', message: `${agentJobs.length} agent runs are still active.` });
+  if (pendingIntegrations.length) blockers.push({ code: 'PENDING_INTEGRATION', message: `${pendingIntegrations.length} successful worktree runs are not integrated.`, entityId: pendingIntegrations[0]?.runId });
+  if (localJobs.length) blockers.push({ code: 'ACTIVE_LEGACY_JOBS', message: `${localJobs.length} compatibility Local Jobs are still active.` });
+  if (editSessions.length) blockers.push({ code: 'DIRTY_EDIT_SESSIONS', message: `${editSessions.length} Edit Sessions are not finalized or rolled back.`, entityId: editSessions[0]?.sessionId });
+  if (leases.length) blockers.push({ code: 'ACTIVE_RESOURCE_LEASES', message: `${leases.length} resource leases are still held.` });
+  if (unfinishedTasks.length) blockers.push({ code: 'REQUIRED_TASKS_INCOMPLETE', message: `${unfinishedTasks.length} tasks in active Issues are not terminal.`, entityId: unfinishedTasks[0]?.taskId });
+  if (staleVerificationTasks.length) blockers.push({ code: 'VERIFICATION_REVISION_STALE', message: `${staleVerificationTasks.length} completed tasks are verified against a different revision.`, entityId: staleVerificationTasks[0]?.task.id });
+  if (missingVerificationTasks.length) blockers.push({ code: 'VERIFICATION_EVIDENCE_MISSING', message: `${missingVerificationTasks.length} completed tasks require persisted verification evidence.`, entityId: missingVerificationTasks[0]?.task.id });
+  if (!repositoryValidation.ok) blockers.push({ code: 'REPOSITORY_IDENTITY_INVALID', message: repositoryValidation.errors.join('; ') || 'Repository validation failed.' });
+  if (repositoryValidation.registryCanonicalRemote && repositoryValidation.canonicalRemote && repositoryValidation.registryCanonicalRemote !== repositoryValidation.canonicalRemote) {
+    blockers.push({ code: 'REGISTRY_REMOTE_DRIFT', message: 'Registry remote differs from Git origin.' });
+  }
+  if (repositoryValidation.githubMappingMatches === false) blockers.push({ code: 'GITHUB_MAPPING_DRIFT', message: 'GitHub mapping differs from Git origin.' });
+  for (const warning of repositoryValidation.warnings) warnings.push({ code: 'REPOSITORY_WARNING', message: warning });
+  if (daemon.status !== 'ready') blockers.push({ code: 'FORGE_RUNTIME_NOT_READY', message: `Forge Runtime is ${daemon.status}.` });
+  if (!pkg.valid) blockers.push({ code: 'PACKAGE_METADATA_INVALID', message: 'package.json must contain a valid name, semantic version, and bin export.' });
+
+  const checks = {
+    revisionResolved: head.ok && revision !== 'unversioned',
+    workspaceClean: status.ok && !status.output,
+    noActiveExecutionJobs: activeJobs.length === 0,
+    noActiveAgentRuns: agentJobs.length === 0,
+    noPendingIntegration: pendingIntegrations.length === 0,
+    noActiveLegacyJobs: localJobs.length === 0,
+    noDirtyEditSessions: editSessions.length === 0,
+    noOtherLeases: leases.length === 0,
+    allRequiredTasksComplete: unfinishedTasks.length === 0,
+    exactRevisionEvidence: staleVerificationTasks.length === 0 && missingVerificationTasks.length === 0,
+    repositoryIdentityValid: repositoryValidation.ok,
+    registryRemoteMatches: !(repositoryValidation.registryCanonicalRemote && repositoryValidation.canonicalRemote && repositoryValidation.registryCanonicalRemote !== repositoryValidation.canonicalRemote),
+    githubMappingMatches: repositoryValidation.githubMappingMatches !== false,
+    controllerDaemonReady: daemon.status === 'ready',
+    packageMetadataValid: pkg.valid,
+  };
+  return {
+    releaseReady: blockers.length === 0,
+    checkedAt: new Date().toISOString(),
+    revision,
+    blockers,
+    warnings,
+    checks,
+    manifest: {
+      repoId: job.repoId,
+      revision,
+      verifiedTaskIds: completedTasks.filter(({ task }) => task.verification).map(({ task }) => task.id),
+      evidenceJobIds: [job.jobId],
+      packageName: pkg.name,
+      packageVersion: pkg.version,
+    },
+  };
+}

package/src/runtime/resources/claims/conflicts.ts

@@ -0,0 +1,205 @@
+import type { ResourceClaimSpec } from '../../execution/jobs/types';
+import type { ExecutionLease } from '../leases/types';
+
+/**
+ * Resource claim conflict model.
+ *
+ * Workspace is one resource key per checkout:
+ *   workspace:<checkoutId>  mode=read|write|exclusive
+ *
+ * Multiple reads may share; any write/exclusive conflicts with other modes
+ * on the same resource (see claimsConflict).
+ *
+ * Legacy keys:
+ *   workspace-read:<checkoutId>  → treated as workspace:<checkoutId> mode=read
+ */
+
+function normalizeResourceKey(key: string): string {
+  const trimmed = key.trim();
+  if (trimmed.startsWith('workspace-read:')) {
+    return `workspace:${trimmed.slice('workspace-read:'.length)}`;
+  }
+  return trimmed;
+}
+
+function pathValue(key: string): string | undefined {
+  if (!key.startsWith('path:')) return undefined;
+  const raw = key.slice('path:'.length).replace(/^\.\//, '');
+  // Support path:<checkoutId>:<relative> and legacy path:<relative>
+  const parts = raw.split(':');
+  if (parts.length >= 2 && !parts[0]!.includes('/') && !parts[0]!.includes('.')) {
+    // checkout-scoped: return relative path portion for overlap checks
+    return parts.slice(1).join(':').replace(/^\.\//, '');
+  }
+  return raw;
+}
+
+function pathCheckoutId(key: string): string | undefined {
+  if (!key.startsWith('path:')) return undefined;
+  const raw = key.slice('path:'.length);
+  const parts = raw.split(':');
+  if (parts.length >= 2 && !parts[0]!.includes('/') && !parts[0]!.includes('.')) {
+    return parts[0];
+  }
+  return undefined;
+}
+
+function workspaceCheckoutId(key: string): string | undefined {
+  const normalized = normalizeResourceKey(key);
+  return normalized.startsWith('workspace:') ? normalized.slice('workspace:'.length) : undefined;
+}
+
+function gitIndexCheckoutId(key: string): string | undefined {
+  if (key.startsWith('git-index:')) return key.slice('git-index:'.length);
+  if (key.startsWith('git-head:')) return key.slice('git-head:'.length);
+  return undefined;
+}
+
+function isGitRefKey(key: string): boolean {
+  return key.startsWith('git-ref:') || key.startsWith('git-refs:');
+}
+
+/**
+ * Normalize path for overlap checks.
+ * Returns null when the path cannot be safely compared (symlink markers,
+ * case-fold ambiguity markers, empty, absolute escape). Callers must treat
+ * null as "overlap unknown" → conflict conservatively.
+ */
+export function normalizeClaimPath(raw: string): string | null {
+  if (!raw || typeof raw !== 'string') return null;
+  let path = raw.replace(/\\/g, '/').replace(/^\.\//, '');
+  // Reject absolute and parent-escape for claim paths (workspace write instead).
+  if (path.startsWith('/') || path.startsWith('~/') || path.includes('\0')) return null;
+  const segments = path.split('/').filter((s) => s.length > 0 && s !== '.');
+  const out: string[] = [];
+  for (const seg of segments) {
+    if (seg === '..') return null;
+    // Symlink-ish or case-ambiguous markers we cannot prove safe.
+    if (seg.includes('->') || seg === '*') return null;
+    out.push(seg);
+  }
+  if (out.length === 0) return null;
+  return out.join('/');
+}
+
+export function pathOverlaps(left: string, right: string): boolean {
+  const aNorm = normalizeClaimPath(left);
+  const bNorm = normalizeClaimPath(right);
+  // Unsafe / un-normalizable paths: conservative overlap.
+  if (aNorm === null || bNorm === null) return true;
+  const a = aNorm.replace(/\*\*?$/, '').replace(/\/$/, '');
+  const b = bNorm.replace(/\*\*?$/, '').replace(/\/$/, '');
+  return a === b || a.startsWith(`${b}/`) || b.startsWith(`${a}/`);
+}
+
+/**
+ * Resource key overlap for mutation ownership.
+ * workspace:<checkoutId> conflicts with same-checkout path/index/head and with
+ * unscoped path claims (legacy paths lack checkout identity). Repository-scoped
+ * Git refs are independent from checkout-local file mutations; commands that
+ * mutate both already claim their own workspace plus refs explicitly.
+ *
+ * Note: same-key overlap is true even when modes differ; mode policy lives in
+ * claimsConflict (read+read allowed).
+ */
+export function resourceKeysOverlap(leftRaw: string, rightRaw: string): boolean {
+  const left = normalizeResourceKey(leftRaw);
+  const right = normalizeResourceKey(rightRaw);
+  if (left === right) return true;
+
+  if (left === 'repo-content:*') {
+    return right === 'repo-content:*'
+      || right.startsWith('path:')
+      || right.startsWith('workspace:')
+      || isGitRefKey(right)
+      || right.startsWith('git-index:')
+      || right.startsWith('git-head:');
+  }
+  if (right === 'repo-content:*') {
+    return left.startsWith('path:')
+      || left.startsWith('workspace:')
+      || isGitRefKey(left)
+      || left.startsWith('git-index:')
+      || left.startsWith('git-head:');
+  }
+
+  const leftWs = workspaceCheckoutId(left);
+  const rightWs = workspaceCheckoutId(right);
+  if (leftWs && rightWs) return leftWs === rightWs;
+
+  // workspace vs path (checkout-scoped or legacy unscoped)
+  if (leftWs && right.startsWith('path:')) {
+    const pathCheckout = pathCheckoutId(right);
+    return pathCheckout === undefined || pathCheckout === leftWs;
+  }
+  if (rightWs && left.startsWith('path:')) {
+    const pathCheckout = pathCheckoutId(left);
+    return pathCheckout === undefined || pathCheckout === rightWs;
+  }
+
+  // workspace vs git-index/head for same checkout. Git refs themselves are
+  // repo-scoped but do not mutate another checkout's files; a command that
+  // touches refs and a checkout declares both claims, so same-checkout safety
+  // is still enforced by its workspace/index claim.
+  if (leftWs) {
+    const indexCheckout = gitIndexCheckoutId(right);
+    if (indexCheckout !== undefined) return indexCheckout === leftWs;
+  }
+  if (rightWs) {
+    const indexCheckout = gitIndexCheckoutId(left);
+    if (indexCheckout !== undefined) return indexCheckout === rightWs;
+  }
+
+  const leftPath = pathValue(left);
+  const rightPath = pathValue(right);
+  if (leftPath !== undefined && rightPath !== undefined) {
+    const leftCheckout = pathCheckoutId(left);
+    const rightCheckout = pathCheckoutId(right);
+    if (leftCheckout && rightCheckout && leftCheckout !== rightCheckout) return false;
+    return pathOverlaps(leftPath, rightPath);
+  }
+
+  if (isGitRefKey(left) && isGitRefKey(right)) return true;
+
+  return false;
+}
+
+export function resourceClaimsConflict(
+  left: Pick<ResourceClaimSpec, 'resourceKey' | 'mode'>,
+  right: Pick<ResourceClaimSpec, 'resourceKey' | 'mode'>,
+): boolean {
+  const leftKey = normalizeResourceKey(left.resourceKey);
+  const rightKey = normalizeResourceKey(right.resourceKey);
+  const leftRelease = leftKey.startsWith('release:');
+  const rightRelease = rightKey.startsWith('release:');
+  if (leftRelease || rightRelease) {
+    if (leftRelease && rightRelease) return true;
+    // Release Freeze blocks mutations and external effects but intentionally
+    // allows read-only observation and Schedule triage to remain available.
+    const nonReleaseMode = leftRelease ? right.mode : left.mode;
+    return nonReleaseMode !== 'read';
+  }
+  if (!resourceKeysOverlap(leftKey, rightKey)) return false;
+  // Read + read may share; any write/exclusive conflicts.
+  return left.mode !== 'read' || right.mode !== 'read';
+}
+
+export function claimsConflict(claim: ResourceClaimSpec, lease: ExecutionLease): boolean {
+  return resourceClaimsConflict(claim, lease);
+}
+
+export function normalizeClaims(claims: ResourceClaimSpec[], options: { readOnly?: boolean } = {}): ResourceClaimSpec[] {
+  if (claims.length === 0) {
+    return options.readOnly ? [] : [{ resourceKey: 'repo-content:*', mode: 'write' }];
+  }
+  const map = new Map<string, ResourceClaimSpec>();
+  for (const claim of claims) {
+    const key = normalizeResourceKey(claim.resourceKey);
+    if (!key) continue;
+    const existing = map.get(key);
+    if (!existing || existing.mode === 'read' && claim.mode !== 'read' || existing.mode === 'write' && claim.mode === 'exclusive') {
+      map.set(key, { ...claim, resourceKey: key });
+    }
+  }
+  return [...map.values()];
+}

package/src/runtime/resources/index.ts

@@ -0,0 +1 @@
+export * from './ownership';