@moretea-labs/forge 1.8.0 → 1.8.2

package/src/cli/controller/operational-plan.ts

@@ -18,13 +18,13 @@ export interface ControllerOperationalPlan {
     reviewRequired: boolean;
   };
   validationStrategy: {
-    source: "task-targeted-validation-policy";
+    source: "declared-check-projection";
     policy: "minimal" | "task-targeted" | "release-gate";
     checks: string[];
     reason: string;
   };
   recipeSystem: {
-    source: "controller-recipe-system";
+    source: "legacy-recipe-projection";
     recipes: Array<{
       id: string;
       label: string;
@@ -34,7 +34,7 @@ export interface ControllerOperationalPlan {
     }>;
   };
   workerAbstraction: {
-    source: "worker-routing-abstraction";
+    source: "execution-capability-projection";
     workers: Array<{
       id: string;
       role: string;
@@ -107,11 +107,9 @@ export function buildControllerOperationalPlan(repoRoot: string, ledger: TaskLed
   const dirty = changedFiles.length > 0;
   const blocked = ledger.status.kind === "blocked" || ledger.status.kind === "needs_retry_decision";
   const needsAttention = blocked || ledger.status.severity === "action" || ledger.status.severity === "warning" || dirty;
-  const policy = checks.some((check) => check.includes("release") || check.includes("ci"))
-    ? "release-gate" as const
-    : checks.length > 0
-      ? "task-targeted" as const
-      : "minimal" as const;
+  // Compatibility projection only. Declared checks are facts the model may use;
+  // this projection does not choose a validation method or release gate.
+  const policy = "minimal" as const;
 
   return {
     schemaVersion: OPERATIONAL_PLAN_SCHEMA_VERSION,
@@ -122,70 +120,45 @@ export function buildControllerOperationalPlan(repoRoot: string, ledger: TaskLed
       "task-ledger",
       "context-pack",
       "diff-projection",
-      "validation-strategy",
-      "recipe-system",
-      "worker-abstraction",
+      "declared-check-projection",
+      "legacy-recipe-projection",
+      "execution-capability-projection",
       "gui-interaction-model",
       "mcp-tool-schema-convergence",
       "controller-home-runtime-storage-policy",
       "branch-worktree-cleanup-policy",
       "task-recovery-loop",
     ],
-    remainingDecisionPoints: dirty
-      ? ["Review and commit or discard current diff before dispatching unrelated work."]
-      : [],
+    remainingDecisionPoints: [],
     diffProjection: {
       source: "live-git-diff-projection",
       dirty,
       changedFiles,
       diffStat: diffStat.ok ? diffStat.stdout.trim() : diffStat.error || diffStat.stderr.trim(),
-      reviewRequired: dirty,
+      // Legacy field retained for UI ABI only. Dirty state is a fact, not an
+      // automatic review lifecycle decision.
+      reviewRequired: false,
     },
     validationStrategy: {
-      source: "task-targeted-validation-policy",
+      source: "declared-check-projection",
       policy,
       checks,
-      reason: policy === "release-gate"
-        ? "Release or CI checks are declared by the focused work."
-        : policy === "task-targeted"
-          ? "Use checks declared on the focused task or ready queue; do not expand validation scope by default."
-          : "No task-specific checks were found; keep validation minimal and explicit.",
+      reason: checks.length > 0
+        ? "These checks are declared context only; the model decides whether, when, and how to validate."
+        : "No declared checks were found; Forge does not invent a validation strategy.",
     },
     recipeSystem: {
-      source: "controller-recipe-system",
-      recipes: [
-        {
-          id: "scoped-direct-edit",
-          label: "Scoped direct edit",
-          when: "Known files and low/medium-risk bounded changes.",
-          steps: ["build context pack", "read exact ranges", "apply bounded patch", "review diff projection", "run task-targeted checks"],
-          requiredEvidence: ["contextPack", "diffProjection", "validationStrategy"],
-        },
-        {
-          id: "isolated-worker-run",
-          label: "Isolated worker run",
-          when: "Large, risky, or long-running implementation requiring agent execution.",
-          steps: ["derive worker scope", "dispatch isolated run", "inspect run diff", "integrate through edit session", "verify exact revision"],
-          requiredEvidence: ["run", "task diff", "integration session", "checks"],
-        },
-        {
-          id: "recovery-resume",
-          label: "Fresh-session recovery",
-          when: "A controller session restarts or loses conversation state.",
-          steps: ["load task ledger", "read operational plan", "select continuation state", "expand only needed context", "resume or ask for the one missing decision"],
-          requiredEvidence: ["taskLedger", "operationalPlan", "recoveryArtifacts"],
-        },
-      ],
+      source: "legacy-recipe-projection",
+      recipes: [],
     },
     workerAbstraction: {
-      source: "worker-routing-abstraction",
+      source: "execution-capability-projection",
       workers: [
-        { id: "direct_edit", role: "transactional patch executor", preferredFor: ["small scoped edits", "known paths"], avoidWhen: ["unknown architecture", "long-running generation"] },
-        { id: "quick_agent", role: "bounded investigation or small implementation", preferredFor: ["uncertain file discovery", "medium-risk changes"], avoidWhen: ["dirty main workspace", "release-critical changes"] },
-        { id: "isolated_task_run", role: "durable worker with worktree", preferredFor: ["parallel tasks", "risky implementation"], avoidWhen: ["single-line fixes"] },
-        { id: "github_copilot", role: "visible cloud coding session", preferredFor: ["remote reviewable work", "GitHub issue flow"], avoidWhen: ["secret-local context", "offline tasks"] },
+        { id: "direct_capability", role: "direct domain capability execution", preferredFor: [], avoidWhen: [] },
+        { id: "isolated_process", role: "isolated process/workspace capability when explicitly useful", preferredFor: [], avoidWhen: [] },
+        { id: "external_provider", role: "optional external model/provider capability", preferredFor: [], avoidWhen: [] },
       ],
-      recommendedWorker: dirty ? "direct_edit" : ledger.status.kind === "ready_to_dispatch" ? "isolated_task_run" : "direct_edit",
+      recommendedWorker: "model_selected",
     },
     guiInteraction: {
       source: "controller-console-interaction-model",
@@ -196,7 +169,7 @@ export function buildControllerOperationalPlan(repoRoot: string, ledger: TaskLed
     mcpToolSchemaConvergence: {
       source: "mcp-tool-schema-convergence",
       readModels: ["controller_context", "rh_context", "work_status_digest", "prepare_transfer_artifacts"],
-      commandModels: ["rh_work", "run_check", "repository_command_execute", "plugin_action_execute", "repository_safe_patch_apply"],
+      commandModels: ["rh_work", "run_check", "execute_command", "plugin_action_execute", "repository_safe_patch_apply"],
       compatibilityRules: [
         "compact reads are default",
         "raw code and raw logs require explicit opt-in tools",

package/src/cli/controller/runtime-config.ts

@@ -6,7 +6,11 @@ export { FORGE_VERSION } from '../../version';
 /** Product identity exposed by every Forge runtime surface. */
 export const FORGE_TOOL_SURFACE = FORGE_PRODUCT_ID;
 /** Payload schema for MCP health/config records; this is not a product/component version. */
-export const FORGE_MCP_SCHEMA_VERSION = 10;
+// 12: autonomous continuation is addressed by Workflow Supervisor task identity
+// rather than optional Work identity. Tool names stay bounded; the served input
+// schema changes and therefore must fence stale Connector schema snapshots.
+// A served-schema change must be visible to connector freshness checks.
+export const FORGE_MCP_SCHEMA_VERSION = 12;
 
 type ToolSurfaceDefinition = {
   name: string;

package/src/cli/controller/stuck-state-migration.ts

@@ -3,7 +3,7 @@ import { spawnSync } from 'child_process';
 import { createHash } from 'crypto';
 import { inspectCompletionBacklog, type CompletionBacklogItem } from './completion-backlog';
 import { getIssue, listIssues, updateIssue, updateTask } from './issue-store';
-import { completionEvidenceComplete, taskExecutionPolicy, verificationEvidencePassed } from './execution-policy';
+import { completionEvidenceComplete, verificationEvidencePassed } from './execution-policy';
 import type { CompletionReceipt, ControllerIssue, ControllerTask } from './types';
 import { resolveCompletionTargetBranch } from './completion-target';
 import { legacyIssueAuthorityRetired } from './legacy-issue-cutover';
@@ -174,8 +174,7 @@ function reachable(repoRoot: string, revision: string, branch: string): boolean
 
 function historicalCompletionReceipt(repoRoot: string, issue: ControllerIssue, task: ControllerTask): CompletionReceipt | undefined {
   if (!task.verification) return undefined;
-  const policy = taskExecutionPolicy(task);
-  const outcome = verificationEvidencePassed(task, task.verification, policy);
+  const outcome = verificationEvidencePassed(task, task.verification);
   if (!outcome.ok) return undefined;
   const target = currentTarget(repoRoot);
   if (!target) return undefined;

package/src/cli/controller/systemd-user.ts

@@ -1,7 +1,8 @@
+import { writeAtomicTextFile } from '../../runtime/shared/atomic-text-file';
 import { spawnSync, type SpawnSyncReturns } from 'child_process';
-import { mkdirSync, renameSync, writeFileSync } from 'fs';
+import { existsSync, rmSync } from 'fs';
 import { homedir } from 'os';
-import { dirname, join } from 'path';
+import { join } from 'path';
 
 export interface SystemdUserUnitInput {
   description?: string;
@@ -12,13 +13,6 @@ export interface SystemdUserUnitInput {
   restartSec?: number;
 }
 
-function atomicWrite(path: string, content: string, mode = 0o644): void {
-  mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
-  const temporary = `${path}.${process.pid}.tmp`;
-  writeFileSync(temporary, content, { encoding: 'utf8', mode });
-  renameSync(temporary, path);
-}
-
 export function systemdEscape(value: string): string {
   return `"${value.replaceAll('%', '%%').replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 }
@@ -79,7 +73,7 @@ export function writeSystemdUserUnit(
   env: NodeJS.ProcessEnv = process.env,
 ): string {
   const unitPath = systemdUserUnitPath(unitName, env);
-  atomicWrite(unitPath, renderSystemdUserUnit(input), 0o644);
+  writeAtomicTextFile(unitPath, renderSystemdUserUnit(input), 0o644);
   return unitPath;
 }
 
@@ -108,3 +102,41 @@ export function systemdUserServicePid(unitName: string, env: NodeJS.ProcessEnv =
   const pid = Number(result.stdout.trim());
   return Number.isInteger(pid) && pid > 0 ? pid : undefined;
 }
+
+export interface ExactSystemdUserUnitRetirementResult {
+  unitName: string;
+  unitPath: string;
+  serviceWasPresent: boolean;
+  unitFileWasPresent: boolean;
+  absentAfter: boolean;
+}
+
+function systemdUnitLoaded(unitName: string, env: NodeJS.ProcessEnv): boolean {
+  const result = commandSucceeded('systemctl', ['--user', 'show', '--property', 'LoadState', '--value', systemdUserUnitName(unitName)], env);
+  return result.status === 0 && result.stdout.trim() !== '' && result.stdout.trim() !== 'not-found';
+}
+
+export function retireSystemdUserUnitExact(
+  input: { unitName: string; env?: NodeJS.ProcessEnv },
+): ExactSystemdUserUnitRetirementResult {
+  const env = input.env ?? process.env;
+  const unitName = systemdUserUnitName(input.unitName);
+  const unitPath = systemdUserUnitPath(unitName, env);
+  const serviceWasPresent = systemdUnitLoaded(unitName, env);
+  const unitFileWasPresent = existsSync(unitPath);
+  if (serviceWasPresent || unitFileWasPresent) {
+    const disabled = commandSucceeded('systemctl', ['--user', 'disable', '--now', unitName], env);
+    const detail = `${disabled.stderr ?? ''}\n${disabled.stdout ?? ''}`;
+    if (disabled.status !== 0 && !/not loaded|not found|does not exist|not enabled|no files found/i.test(detail)) {
+      throw new Error(`SYSTEMD_USER_EXACT_RETIRE_FAILED: ${unitName}: ${detail.trim()}`);
+    }
+  }
+  rmSync(unitPath, { force: true });
+  const reload = commandSucceeded('systemctl', ['--user', 'daemon-reload'], env);
+  if (reload.status !== 0) {
+    throw new Error(`SYSTEMD_USER_EXACT_RETIRE_RELOAD_FAILED: ${unitName}: ${(reload.stderr || reload.stdout || '').trim()}`);
+  }
+  const absentAfter = !systemdUnitLoaded(unitName, env) && !existsSync(unitPath);
+  if (!absentAfter) throw new Error(`SYSTEMD_USER_EXACT_RETIRE_VERIFY_FAILED: ${unitName}`);
+  return { unitName, unitPath, serviceWasPresent, unitFileWasPresent, absentAfter };
+}

package/src/cli/editing/edit-session.ts

@@ -9,8 +9,8 @@ import {
   type ControllerCheckResult,
 } from '../controller/check-runner';
 import { tryAppendControllerWorklogEvent } from '../controller/worklog';
-import { globMatches, resolveMcpPath } from '../mcp/paths';
-import type { McpPolicy } from '../mcp/types';
+import { globMatches, resolveMcpPath } from '../../../adapters/mcp/paths';
+import type { McpPolicy } from '../../../adapters/mcp/types';
 import type { ProcessCheckCompletionReceipt, ProcessCheckReceiptStatus } from '../../runtime/execution/process-runtime/check-receipt';
 import { invalidateRepositoryReadCaches } from '../repository/inspector';
 import type { EditOperation } from './edit-operation-contract';
@@ -86,7 +86,6 @@ export interface EditSessionBinding {
   checkoutId?: string;
   principalId?: string;
   controllerInstanceId?: string;
-  routeDecisionFingerprint?: string;
 }
 
 export interface EditSession {
@@ -99,7 +98,6 @@ export interface EditSession {
   checkoutId?: string;
   principalId?: string;
   controllerInstanceId?: string;
-  routeDecisionFingerprint?: string;
   workspaceFingerprint?: string;
   assurance?: EditSessionAssurance;
   purpose: string;
@@ -293,8 +291,7 @@ export function assertEditSessionDurableBinding(
     session.workId
     || session.repoId
     || session.checkoutId
-    || session.principalId
-    || session.routeDecisionFingerprint,
+    || session.principalId,
   );
   if (options.requireBoundIdentity === true && hasDurableIdentity && !binding) {
     throw new Error('EDIT_SESSION_IDENTITY_MISMATCH: binding');
@@ -305,7 +302,6 @@ export function assertEditSessionDurableBinding(
     ['repoId', session.repoId, binding.repoId],
     ['checkoutId', session.checkoutId, binding.checkoutId],
     ['principalId', session.principalId, binding.principalId],
-    ['routeDecisionFingerprint', session.routeDecisionFingerprint, binding.routeDecisionFingerprint],
   ];
   for (const [field, expected, observed] of pairs) {
     if (expected && expected !== observed) throw new Error(`EDIT_SESSION_IDENTITY_MISMATCH: ${String(field)}`);
@@ -316,6 +312,10 @@ function bindSessionControllerInstance(repoRoot: string, session: EditSession, b
   assertEditSessionDurableBinding(session, binding);
   const nextInstanceId = binding?.controllerInstanceId?.trim();
   if (!nextInstanceId || session.controllerInstanceId === nextInstanceId) return session;
+  // A non-Work Safe Patch session has no Controller instance owner to rebind.
+  // Its persisted repository identity is still checked above; never promote
+  // a caller-supplied transient Runtime identity into durable session authority.
+  if (!session.workId && !session.controllerInstanceId) return session;
   const durableIdentity = [
     [session.workId, binding?.workId],
     [session.repoId, binding?.repoId],
@@ -404,7 +404,6 @@ function normalizeStoredSession(value: Partial<EditSession> & { sessionId: strin
     checkoutId: value.checkoutId,
     principalId: value.principalId,
     controllerInstanceId: value.controllerInstanceId,
-    routeDecisionFingerprint: value.routeDecisionFingerprint,
     workspaceFingerprint: value.workspaceFingerprint,
     assurance: value.assurance,
     purpose: value.purpose ?? 'Direct edit',
@@ -1149,7 +1148,7 @@ function sessionSummary(session: EditSession): EditSessionSummary {
   };
 }
 
-function findOccurrence(value: string, anchor: string, occurrence: number): number {
+export function findOccurrence(value: string, anchor: string, occurrence: number): number {
   let from = 0;
   for (let current = 1; current <= occurrence; current += 1) {
     const index = value.indexOf(anchor, from);
@@ -1206,7 +1205,6 @@ export function beginEditSession(repoRoot: string, input: {
     checkoutId: input.binding?.checkoutId?.trim() || undefined,
     principalId: input.binding?.principalId?.trim() || undefined,
     controllerInstanceId: input.binding?.controllerInstanceId?.trim() || undefined,
-    routeDecisionFingerprint: input.binding?.routeDecisionFingerprint?.trim() || undefined,
     workspaceFingerprint: workspaceFingerprint(repoRoot),
     purpose,
     status: 'open',
@@ -1919,9 +1917,17 @@ export function finalizeEditSession(repoRoot: string, sessionId: string, input:
 } = {}): EditSession {
   let session = getEditSession(repoRoot, sessionId);
   session = bindSessionControllerInstance(repoRoot, session, input.binding);
-  if (session.baseRevision && gitRevision(repoRoot) !== session.baseRevision) throw new Error('EDIT_SESSION_BASE_REVISION_CHANGED');
-  if (session.workspaceFingerprint && workspaceFingerprint(repoRoot) !== session.workspaceFingerprint) throw new Error('EDIT_SESSION_WORKSPACE_FINGERPRINT_CHANGED');
+  const baseRevisionChanged = Boolean(session.baseRevision && gitRevision(repoRoot) !== session.baseRevision);
+  const workspaceFingerprintChanged = Boolean(session.workspaceFingerprint && workspaceFingerprint(repoRoot) !== session.workspaceFingerprint);
   if (session.assurance?.approvalRequired && input.approvalConfirmed !== true) throw new Error('EDIT_SESSION_APPROVAL_REQUIRED');
+  if (baseRevisionChanged || workspaceFingerprintChanged) {
+    // A commit changes HEAD and Git's workspace fingerprint even when the exact edit-session after-images are now integrated.
+    // Reconcile through the canonical after-image + clean-tracked-path checks before rejecting the stale snapshot.
+    const reconciled = reconcileEditSession(repoRoot, session.sessionId, input);
+    if (reconciled.status === 'finalized' || reconciled.status === 'superseded') return reconciled;
+    if (baseRevisionChanged) throw new Error('EDIT_SESSION_BASE_REVISION_CHANGED');
+    throw new Error('EDIT_SESSION_WORKSPACE_FINGERPRINT_CHANGED');
+  }
   const emptyOpenSession = session.status === 'open' && session.operations.length === 0;
   if (!emptyOpenSession && !['dirty', 'checked', 'check_failed'].includes(session.status)) {
     throw new Error(`edit session cannot be finalized from ${session.status}`);

package/src/cli/github/github.ts

@@ -121,7 +121,7 @@ export function buildGitHubWorkflowDispatchArgs(repository: string, input: GitHu
   return args;
 }
 
-function gh(repoRoot: string, args: string[], input?: string, maxOutputBytes = 512 * 1024) {
+export function gh(repoRoot: string, args: string[], input?: string, maxOutputBytes = 512 * 1024) {
   return runProcess('gh', args, {
     cwd: repoRoot,
     timeoutMs: 120_000,
@@ -284,7 +284,7 @@ function parseIssueUrl(output: string): { url: string; number: number } {
   return { url, number };
 }
 
-function addProjectItem(repoRoot: string, link: GitHubIssueLink, projectOwner?: string, projectNumber?: number): GitHubIssueLink {
+export function addProjectItem(repoRoot: string, link: GitHubIssueLink, projectOwner?: string, projectNumber?: number): GitHubIssueLink {
   if (!projectOwner || !projectNumber) return link;
   const result = gh(repoRoot, ['project', 'item-add', String(projectNumber), '--owner', projectOwner, '--url', link.url, '--format', 'json']);
   if (!result.ok) throw new Error(`failed to add ${link.url} to GitHub Project: ${result.error || result.stderr}`);
@@ -302,7 +302,7 @@ function withoutPairedOption(args: string[], option: string): string[] {
   return args.filter((entry, index, all) => entry !== option && all[index - 1] !== option);
 }
 
-function createGitHubIssue(repoRoot: string, repo: GitHubRepositoryInfo, title: string, bodyPath: string, labels: string[], parentNumber?: number): GitHubIssueLink {
+export function createGitHubIssue(repoRoot: string, repo: GitHubRepositoryInfo, title: string, bodyPath: string, labels: string[], parentNumber?: number): GitHubIssueLink {
   const args = ['issue', 'create', '--repo', repo.nameWithOwner, '--title', title, '--body-file', bodyPath];
   for (const label of labels) args.push('--label', label);
   if (parentNumber) args.push('--parent', String(parentNumber));
@@ -323,7 +323,7 @@ function createGitHubIssue(repoRoot: string, repo: GitHubRepositoryInfo, title:
   return { owner: repo.owner, repo: repo.repo, number: parsed.number, url: parsed.url, syncedAt: new Date().toISOString() };
 }
 
-function updateGitHubIssue(repoRoot: string, repo: GitHubRepositoryInfo, link: GitHubIssueLink, title: string, bodyPath: string): GitHubIssueLink {
+export function updateGitHubIssue(repoRoot: string, repo: GitHubRepositoryInfo, link: GitHubIssueLink, title: string, bodyPath: string): GitHubIssueLink {
   const result = gh(repoRoot, ['issue', 'edit', String(link.number), '--repo', repo.nameWithOwner, '--title', title, '--body-file', bodyPath]);
   if (!result.ok) throw new Error(`failed to update GitHub issue #${link.number}: ${result.error || result.stderr}`);
   return { ...link, owner: repo.owner, repo: repo.repo, syncedAt: new Date().toISOString() };

package/src/cli/github/semantic-projection.ts

@@ -0,0 +1,174 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { listRepositories } from '../repositories/registry';
+import { resolveRepoPreferredControllerHome } from '../repositories/controller-home';
+import { getWorkContract, listWorkContracts, type WorkContract } from '../../../packages/kernel/work/api/index';
+import { getPlanContract, planSemanticView } from '../../runtime/control-plane/facade/plan-contract-store';
+import { readRequirement } from '../../runtime/control-plane/persistence/requirement-store';
+import type { GitHubIssueLink } from '../controller/types';
+import { gh, createGitHubIssue, updateGitHubIssue, addProjectItem, resolveGitHubRepository } from './github';
+
+interface RemoteIssue { number: number; url: string; title: string; body: string }
+export interface SemanticReleaseProjectionInput {
+  releaseWorkId: string;
+  repository?: string;
+  projectOwner?: string;
+  projectNumber?: number;
+}
+export interface SemanticReleaseProjectionResult {
+  releaseIssue: string;
+  children: Array<{ workId: string; issue: string }>;
+  created: number;
+  updated: number;
+  unchanged: number;
+}
+
+function safeIdentity(value: string): string {
+  if (!/^[A-Za-z0-9_.:-]{1,200}$/.test(value)) throw new Error('GITHUB_SEMANTIC_ID_INVALID');
+  return value;
+}
+
+function marker(workId: string): string {
+  return '<!-- forge-semantic-work:' + safeIdentity(workId) + ' -->';
+}
+
+function lines(values: readonly string[] | undefined, prefix = '- '): string {
+  return values?.length ? values.map((line) => prefix + line).join('\n') : '- 尚无记录';
+}
+
+function workDisplayTitle(work: WorkContract, home: string): string {
+  const requirement = work.requirementId
+    ? readRequirement({ controllerHome: home }, work.requirementId)?.value
+    : undefined;
+  return (requirement?.title || work.objective).replace(/\s+/g, ' ').slice(0, 96);
+}
+
+function semanticWorkText(work: WorkContract, home: string): string {
+  const requirement = work.requirementId
+    ? readRequirement({ controllerHome: home }, work.requirementId)?.value
+    : undefined;
+  const plan = work.planId
+    ? getPlanContract({ controllerHome: home, repoId: work.repoId }, work.planId)
+    : undefined;
+  const planView = plan ? planSemanticView(plan) : undefined;
+  const text = [
+    marker(work.workId),
+    '> Forge 生成视图（单向投影）。Requirement / Plan / Work 的正式状态只由 Forge 持有。GitHub 上的勾选或评论不改变执行授权。',
+    '',
+    '## 工作目标', work.objective,
+    '',
+    '## Forge 当前事实',
+    '- Work: `' + work.workId + '`',
+    '- 语义状态: `' + work.semanticState + '`',
+    '- Requirement: `' + (work.requirementId || '未绑定') + '`',
+    '- Plan: `' + (work.planId || '未绑定') + '`',
+    '- 父 Work: `' + (work.semanticParentWorkId || '无') + '`',
+    '- 最近语义更新: ' + (work.semanticUpdatedAt || work.updatedAt),
+    '',
+    '## 已选择的交付结果引用',
+    lines(work.semanticResultRefs),
+  ];
+  if (requirement) {
+    text.push('', '## 原始需求：' + requirement.title, requirement.outcomeStatement, '',
+      '### 验收标准', lines(requirement.acceptanceCriteria));
+    if (requirement.needsAttention && requirement.attentionSummary) {
+      text.push('', '### Forge 记录的需关注事项', requirement.attentionSummary);
+    }
+  }
+  if (planView) {
+    text.push('', '## 当前方案', planView.goal, '',
+      '### 方案决定', lines(planView.resolvedDecisions), '',
+      '### 方案项（描述性工作记忆，不是自动审批状态）',
+      lines(planView.items.map((item) => item.id + ' — ' + item.objective)));
+  }
+  text.push('', '> 未明确记录的用户产品审批、测试、发布均不能推断为通过。');
+  return text.join('\n') + '\n';
+}
+
+export function syncGitHubSemanticRelease(
+  repoRoot: string,
+  input: SemanticReleaseProjectionInput,
+): SemanticReleaseProjectionResult {
+  const home = resolveRepoPreferredControllerHome(repoRoot);
+  const repositoryRecord = listRepositories(home).find((record) =>
+    record.canonicalRoot === repoRoot || record.localRoot === repoRoot ||
+    record.checkouts.some((checkout) => checkout.canonicalRoot === repoRoot || checkout.localRoot === repoRoot));
+  if (!repositoryRecord) throw new Error('GITHUB_SEMANTIC_REPOSITORY_NOT_REGISTERED');
+  const repoId = repositoryRecord.repoId;
+  const store = { controllerHome: home, repoId };
+  const releaseWorkId = safeIdentity(input.releaseWorkId);
+  const parent = getWorkContract(store, releaseWorkId);
+  if (!parent || parent.lifecycleRole === 'execution_child') throw new Error('GITHUB_SEMANTIC_RELEASE_WORK_NOT_FOUND');
+  if (parent.semanticParentWorkId) throw new Error('GITHUB_SEMANTIC_RELEASE_MUST_BE_ROOT');
+  const all: WorkContract[] = [];
+  for (let offset = 0; offset < 10_000; offset += 100) {
+    const page = listWorkContracts({ ...store, state: 'all', limit: 100, offset });
+    all.push(...page);
+    if (page.length < 100) break;
+    if (offset + 100 >= 10_000) throw new Error('GITHUB_SEMANTIC_WORK_INVENTORY_TOO_LARGE');
+  }
+  const children = all.filter((work) => work.semanticParentWorkId === releaseWorkId &&
+    work.lifecycleRole !== 'execution_child').sort((a, b) => a.workId.localeCompare(b.workId));
+
+  // The GitHub Issue is a projection; never import remote status back into Work.
+  if (Boolean(input.projectOwner) !== Boolean(input.projectNumber)) throw new Error('GITHUB_SEMANTIC_PROJECT_CONFIG_INCOMPLETE');
+  const repo = resolveGitHubRepository(repoRoot, input.repository);
+  const inventory = gh(repoRoot,
+    ['issue', 'list', '--repo', repo.nameWithOwner, '--state', 'all', '--limit', '1000',
+      '--json', 'number,url,title,body'], undefined, 4 * 1024 * 1024);
+  if (!inventory.ok) throw new Error('GITHUB_SEMANTIC_ISSUE_INVENTORY_FAILED: ' + (inventory.error || inventory.stderr));
+  const remote = JSON.parse(inventory.stdout) as RemoteIssue[];
+  if (!Array.isArray(remote) || remote.length === 1000) {
+    throw new Error('GITHUB_SEMANTIC_ISSUE_INVENTORY_UNBOUNDED');
+  }
+  let created = 0;
+  let updated = 0;
+  let unchanged = 0;
+  const tmp = mkdtempSync(join(tmpdir(), 'forge-semantic-github-'));
+  function ensureIssue(workId: string, title: string, body: string): string {
+    const matches = remote.filter((issue) => issue.body?.includes(marker(workId)));
+    if (matches.length > 1) throw new Error('GITHUB_SEMANTIC_DUPLICATE_REMOTE_IDENTITY: ' + workId);
+    const file = join(tmp, 'issue.md');
+    writeFileSync(file, body, 'utf8');
+    let link: GitHubIssueLink;
+    if (matches.length === 1) {
+      const current = matches[0]!;
+      link = { owner: repo.owner, repo: repo.repo, number: current.number, url: current.url, syncedAt: '' };
+      if (current.title === title && current.body === body) unchanged++;
+      else { link = updateGitHubIssue(repoRoot, repo, link, title, file); updated++; }
+    } else {
+      link = createGitHubIssue(repoRoot, repo, title, file, []);
+      remote.push({ number: link.number, title, body, url: link.url });
+      created++;
+    }
+    if (input.projectOwner && input.projectNumber) {
+      addProjectItem(repoRoot, link, input.projectOwner, input.projectNumber);
+    }
+    return link.url;
+  }
+  try {
+    const linked = children.map((work) => ({
+      workId: work.workId,
+      title: workDisplayTitle(work, home),
+      issue: ensureIssue(work.workId, workDisplayTitle(work, home),
+        semanticWorkText(work, home)),
+    }));
+    const counts = {
+      open: children.filter((work) => work.semanticState === 'open').length,
+      completed: children.filter((work) => work.semanticState === 'completed').length,
+      cancelled: children.filter((work) => work.semanticState === 'cancelled').length,
+    };
+    const releaseBody = semanticWorkText(parent, home) + '\n## 版本关联工作\n' +
+      (linked.length
+        ? linked.map((child) => '- [' + child.title + '](' + child.issue + ') — \`' + child.workId + '\`').join('\n')
+        : '- 暂无已关联子 Work') +
+      '\n\n## 版本进度（真实 Work 事实，不是提交/发布证明）\n' +
+      '- 关联：' + linked.length + '\n- Open：' + counts.open +
+      '\n- Completed：' + counts.completed + '\n- Cancelled：' + counts.cancelled + '\n';
+    const releaseIssue = ensureIssue(releaseWorkId, workDisplayTitle(parent, home), releaseBody);
+    return { releaseIssue, children: linked, created, updated, unchanged };
+  } finally {
+    rmSync(tmp, { recursive: true, force: true });
+  }
+}

package/src/cli/hook/prompt-intents.ts

@@ -465,15 +465,6 @@ export function isAgenticPackagingIntent(ctx: PromptIntentContext): boolean {
   return AGENTIC_PACKAGING.test(ctx.text);
 }
 
-const CODEGRAPH_ROUTE = re(
-  String.raw`(who calls|what calls|callers|callees|impact|impact radius|trace\s+(flow|path|call)|where\s.*(defined|definition)|definition of|symbol named|调用关系|谁调用|调用了谁|哪里定义|定义在哪|影响面|调用链|追踪(路径|调用|链)|从.*到.*怎么走)`,
-);
-
-export function isCodegraphRouteIntent(ctx: PromptIntentContext): boolean {
-  if (isTriggerQuestionPrompt(ctx)) return false;
-  return CODEGRAPH_ROUTE.test(ctx.text);
-}
-
 const GIT_STATUS_LINE = re(
   String.raw`^${SP}*(git\s+(status|log|show|diff|push|pull|commit)|status|commit|push|merge|提交|推送|合并|看状态|看看状态)(${SP}|$)`,
 );