@fitlab-ai/agent-infra 0.11.5 → 0.11.7

package/dist/lib/task/verification-engine.js

@@ -4,14 +4,13 @@ import path from "node:path";
 import process from "node:process";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
-import { extractReviewBaseline, extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, extractReviewDiffFingerprint, extractReviewedSnapshotTree, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
+import { extractReviewTargetHead, extractReviewedHead, extractReviewDiffBase, findAuthoritativeReviewCodeArtifact, loadPostReviewConfig, parseReviewVerdict, resolvePostReviewGlobs } from "./verification-review.js";
 import { check as checkPlatformSync } from "../platform/verification-sync.js";
 import { check as checkRequiredChecks } from "../platform/verification-required.js";
 import { inspectPlatformPullRequest } from "../platform/pull-requests.js";
 import { resolveMaterializedReviewedHeadRelation } from "../platform/change-request-git-evidence.js";
 import { resolveReviewedHeadRelation } from "../platform/merged-pr-equivalence.js";
 import { resolveLocalReviewedCommitRelation } from "../git/reviewed-commit-equivalence.js";
-import { resolveBranchWorktree } from "../git/branch-worktree.js";
 import { parseTypedTaskFrontmatter } from "./frontmatter.js";
 import { LEDGER_TERMINAL, LEDGER_SECTION_MISSING_CODE, LEDGER_SECTION_MISSING_MESSAGE, parseLedgerDocument, summarizeLedgerStage, validateLedgerRows } from "./ledger.js";
 import { isValidAgentInfraVersion } from "../version.js";
@@ -20,11 +19,9 @@ import { inspectDecisionDetailDuplicates } from "./decision-details.js";
 import { parseImplementationInputs } from "./implementation-inputs.js";
 import { scanVisibleMarkdown } from "./markdown.js";
 import { loadVerificationConfig } from "./verification-config.js";
-import { snapshotReview } from "../git/review-snapshot.js";
 import { inspectActivityLog } from "./activity-log.js";
 import { parseWorkflowWarnings } from "./workflow-warnings.js";
 import { OrchestrationStateError, readRun } from "./orchestration.js";
-import { resolveDeliveryTarget } from "./delivery-target.js";
 import { readPrDeliveryFact } from "./pr-delivery-fact.js";
 import { validateLocalArtifact } from "./local-artifact-finalization.js";
 import { getArtifactSchema } from "./artifact-schema.js";
@@ -35,6 +32,8 @@ import { readManualValidationCompletion } from "./manual-validation-completion.j
 import { sha256File } from "./artifact-receipts.js";
 import { summaryCommentState } from "../platform/pr-summary.js";
 import { taskIssueIdentity } from "../platform/task-identities.js";
+import { hasArtifactCompletionFact, hasArtifactCompletionLog } from './completion-facts.js';
+import { inspectReviewIdentity } from './review-identity.js';
 const TASK_ENUMS = {
     type: ["feature", "bugfix", "refactor", "docs", "chore"],
     workflow: ["feature-development", "bug-fix", "refactoring"],
@@ -1014,12 +1013,16 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
         return failResult("review-fact", task.message);
     }
     const content = fs.readFileSync(resolvedArtifact.path, "utf8");
+    if (!hasArtifactCompletionFact(task.content, resolvedArtifact.path, 'review-code.completed')) {
+        return failResult("review-fact", `Review Code completion fact does not match ${path.basename(resolvedArtifact.path)}`);
+    }
+    if (!hasArtifactCompletionLog(task.content, path.basename(resolvedArtifact.path), 'review-code.completed')) {
+        return failResult("review-fact", `Review Code completion entry does not reference ${path.basename(resolvedArtifact.path)}`);
+    }
     const verdict = parseReviewVerdict(content);
     const reviewTargetHead = extractReviewTargetHead(content);
     const reviewReviewedHead = extractReviewedHead(content);
     const reviewDiffBase = extractReviewDiffBase(content);
-    const reviewedFingerprint = extractReviewDiffFingerprint(content);
-    const reviewedTree = extractReviewedSnapshotTree(content);
     if (!["通过", "需要修改", "拒绝", "Approved", "Changes Requested", "Rejected"].includes(verdict)) {
         return failResult("review-fact", `Unsupported review verdict '${verdict}'`);
     }
@@ -1031,71 +1034,19 @@ function checkReviewFact({ taskDir, artifactFile, repositoryRoot }) {
     if (!reviewTargetHead || !reviewReviewedHead || !reviewDiffBase) {
         return failResult("review-fact", "Review fact must record target head, reviewed head, and diff base");
     }
-    let gitRoot;
-    let head;
-    let baseline;
-    let targetHead;
-    let diffBase;
-    try {
-        const taskRepositoryRoot = execFileSync("git", ["-C", taskDir, "rev-parse", "--show-toplevel"], { encoding: "utf8" }).trim();
-        gitRoot = reviewWorktreeForTask(taskRepositoryRoot, String(task.metadata.branch || "").trim()) ?? taskRepositoryRoot;
-        head = execFileSync("git", ["-C", gitRoot, "rev-parse", "HEAD"], { encoding: "utf8" }).trim();
-        const target = resolveDeliveryTarget(gitRoot, { remote: deliveryRemote, baseRef: deliveryBaseRef });
-        if (!target.ok)
-            throw new Error(target.message);
-        const reviewedRef = reviewReviewedHead;
-        baseline = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewedRef}^{commit}`], { encoding: "utf8" }).trim();
-        targetHead = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewTargetHead}^{commit}`], { encoding: "utf8" }).trim();
-        const computed = execFileSync("git", ["-C", gitRoot, "merge-base", baseline, targetHead], { encoding: "utf8" }).trim();
-        diffBase = execFileSync("git", ["-C", gitRoot, "rev-parse", `${reviewDiffBase}^{commit}`], { encoding: "utf8" }).trim();
-        if (diffBase !== computed)
-            throw new Error('saved review diff base does not match merge-base(reviewed head, target head)');
-    }
-    catch {
-        return blockedResult("review-fact", `Unable to resolve saved review commits in the task repository; re-run review-code`);
-    }
-    if (baseline !== head) {
-        return failResult("review-fact", `Reviewed head ${baseline.slice(0, 8)} does not match current HEAD ${head.slice(0, 8)}; re-run review-code`);
-    }
-    let actualSnapshot;
-    try {
-        actualSnapshot = snapshotReview({
-            cwd: gitRoot,
-            mode: "worktree",
-            baseline,
-            diffBase,
-            globs: resolvePostReviewGlobs({}, loadPostReviewConfig(repositoryRoot))
-        });
-    }
-    catch {
-        return blockedResult("review-fact", `Unable to recompute reviewed diff fingerprint from baseline ${baseline.slice(0, 8)}; re-run review-code`);
-    }
-    if (actualSnapshot.fingerprint !== reviewedFingerprint) {
-        return failResult("review-fact", `Reviewed diff fingerprint does not match the current worktree for baseline ${baseline.slice(0, 8)}; re-run review-code`);
-    }
-    if (!reviewedTree || actualSnapshot.tree !== reviewedTree) {
-        return failResult("review-fact", `Reviewed snapshot tree does not match the current worktree for baseline ${baseline.slice(0, 8)}; re-run review-code`);
+    const identity = inspectReviewIdentity(taskDir, content, repositoryRoot);
+    if (identity.status !== 'matched' || !identity.reviewedHead) {
+        return failResult('review-fact', `Review identity is ${identity.status}: ${identity.message}; re-run review-code`);
     }
+    const baseline = identity.reviewedHead;
     if (["通过", "Approved"].includes(verdict)) {
         const lastReviewedCommit = String(task.metadata.last_reviewed_commit || "").trim();
-        const cleanSnapshot = actualSnapshot.tree === execFileSync("git", ["-C", gitRoot, "rev-parse", `${baseline}^{tree}`], { encoding: "utf8" }).trim();
-        if (cleanSnapshot && lastReviewedCommit !== baseline) {
+        if (lastReviewedCommit !== baseline) {
             return failResult("review-fact", `Approved clean review must set task last_reviewed_commit to reviewed head ${baseline.slice(0, 8)}`);
         }
-        if (!cleanSnapshot && lastReviewedCommit) {
-            return failResult("review-fact", "Approved review with uncommitted changes must remain unanchored until commit");
-        }
     }
     return passResult("review-fact", `Review fact valid for ${path.basename(resolvedArtifact.path)} at ${baseline.slice(0, 8)}`);
 }
-function reviewWorktreeForTask(repositoryRoot, branch) {
-    if (!branch)
-        return null;
-    const worktree = resolveBranchWorktree(repositoryRoot, branch);
-    if (worktree)
-        return worktree;
-    throw new Error(`Task branch '${branch}' is not checked out in a registered worktree`);
-}
 function resolvePostReviewBaseline({ gitRoot, lastReviewedCommit, reviewArtifact }) {
     if (SHA_PATTERN.test(lastReviewedCommit) && gitCommitExists(gitRoot, lastReviewedCommit)) {
         return { ok: true, sha: lastReviewedCommit };

package/dist/lib/task/verification.js

@@ -89,47 +89,44 @@ async function verifyTaskEvent(request, options = {}) {
 function statusLabel(status) {
     return status === 'fail' ? 'FAIL' : status === 'blocked' ? 'BLOCKED' : 'pass';
 }
-function renderPayload(payload) {
-    const lines = [];
-    if (Array.isArray(payload.checks)) {
-        const gateMode = typeof payload.gate === 'string';
-        lines.push(gateMode
-            ? `Verification: ${payload.gate} | Skill: ${payload.skill}`
-            : `Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
-        for (const check of payload.checks) {
-            const raw = statusLabel(check.status);
-            const effective = statusLabel(check.effectiveStatus ?? check.status);
-            const reason = check.reason ?? 'CHECK_FAILED';
-            const message = check.message ?? reason;
-            lines.push(`  [${effective}] ${check.checkId ?? check.type} (${check.classification ?? 'hard'}; raw ${raw}; reason ${reason}) - ${message}; ${check.action ?? 'Review validation output'}`);
-        }
-        const summary = payload.summary ?? (() => {
-            const checks = payload.checks;
-            const statuses = checks.map((check) => check.effectiveStatus ?? check.status);
-            return `${statuses.filter((status) => status === 'pass').length} passed, ${statuses.filter((status) => status === 'fail').length} failed${statuses.includes('blocked') ? `, ${statuses.filter((status) => status === 'blocked').length} blocked` : ''}`;
-        })();
-        lines.push('', `Result: ${summary} - ${payload.action}`);
-    }
-    else {
-        lines.push(`Check: ${payload.status} | Skill: ${payload.skill} | Type: ${payload.type}`, '');
-        const raw = statusLabel(payload.status);
-        const effective = statusLabel(payload.effectiveStatus ?? payload.status);
-        const reason = payload.reason ?? 'CHECK_FAILED';
-        lines.push(`  [${effective}] ${payload.checkId ?? payload.type} (${payload.classification ?? 'hard'}; raw ${raw}; reason ${reason}) - ${payload.message ?? reason}; ${payload.action ?? 'Review validation output'}`);
-        const status = payload.effectiveStatus ?? payload.status;
-        const summary = status === 'pass' ? '1 passed, 0 failed'
-            : status === 'blocked' ? '0 passed, 0 failed, 1 blocked' : '0 passed, 1 failed';
-        const action = status === 'pass' ? 'Requested check passed'
-            : status === 'blocked' ? `Resolve blocked ${payload.type} check and re-run check`
-                : `Fix ${payload.type} issues and re-run check`;
-        lines.push('', `Result: ${summary} - ${action}`);
-    }
-    return `${lines.join('\n')}\n`;
-}
 function renderTaskVerification(result) {
     if (result.status === 'failed')
         return `Verification failed: ${result.error?.code ?? 'VERIFY_FAILED'} - ${result.error?.message ?? 'unknown error'}\n`;
-    return result.invocations.map((invocation) => renderPayload(invocation.payload)).join('');
+    const target = `${result.event}${result.artifact ? ` (${result.artifact})` : ''}`;
+    const lines = [`Verification: ${result.status} | Target: ${target} | Skill: ${result.skill}`];
+    const checks = result.invocations.flatMap(({ payload }) => {
+        if (Array.isArray(payload.checks))
+            return payload.checks;
+        return [payload];
+    });
+    const counts = {
+        pass: checks.filter((check) => (check.effectiveStatus ?? check.status) === 'pass').length,
+        fail: checks.filter((check) => (check.effectiveStatus ?? check.status) === 'fail').length,
+        blocked: checks.filter((check) => (check.effectiveStatus ?? check.status) === 'blocked').length
+    };
+    const summary = `${counts.pass} passed, ${counts.fail} failed${counts.blocked > 0 ? `, ${counts.blocked} blocked` : ''}`;
+    lines.push('', `Result: ${summary}`);
+    for (const check of checks) {
+        const rawStatus = check.status;
+        const effectiveStatus = check.effectiveStatus ?? rawStatus;
+        const isSoftWarning = (rawStatus === 'fail' || rawStatus === 'blocked') && effectiveStatus === 'pass';
+        const reason = check.reason ?? 'CHECK_FAILED';
+        const message = check.message ?? reason;
+        const action = check.action ?? 'Review validation output';
+        const id = check.checkId ?? check.type;
+        const isHumanExemptionNotice = id === 'post-review-commit'
+            && typeof message === 'string'
+            && /\bhuman-decided (?:post-review )?exemption\b/i.test(message)
+            && /\bPRC-\d+\s*:/.test(message);
+        if (effectiveStatus === 'pass' && !isSoftWarning && !isHumanExemptionNotice)
+            continue;
+        lines.push(isSoftWarning
+            ? `Warning: ${id} (${rawStatus === 'blocked' ? `raw BLOCKED; ` : ''}${reason}) - ${message}; ${action}`
+            : isHumanExemptionNotice
+                ? `Notice: ${id} - ${message}; ${action}`
+                : `  [${statusLabel(effectiveStatus)}] ${id} (${reason}) - ${message}; ${action}`);
+    }
+    return `${lines.join('\n')}\n`;
 }
 export { VERIFICATION_CATALOG, renderTaskVerification, verifyTaskEvent };
 //# sourceMappingURL=verification.js.map

package/dist/lib/task/write.js

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { isValidAgentInfraVersion, VERSION } from '../version.js';
 import { parseTypedTaskFrontmatter, updateTaskFrontmatter } from './frontmatter.js';
 import { resolveTaskRef } from './resolve-ref.js';
@@ -53,7 +54,7 @@ function errorDetails(error, fallback) {
         message: error instanceof Error ? error.message : String(error)
     };
 }
-function writeTask(request, options = {}) {
+function writeTaskCore(request, options = {}) {
     const resolved = options.taskLocation
         ? {
             ok: true,
@@ -258,5 +259,124 @@ function writeTask(request, options = {}) {
     }
     return { ...successBase, status: 'applied', changed: true };
 }
+function archiveContentsHash(localDir) {
+    const files = [];
+    const walk = (dir) => {
+        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+            if (entry.name.includes('\n') || entry.name.includes('\r') || entry.name === 'manifest.md') {
+                throw new Error(`Archive source path is not valid: ${path.join(dir, entry.name)}`);
+            }
+            const target = path.join(dir, entry.name);
+            const stat = fs.lstatSync(target);
+            if (stat.isSymbolicLink())
+                throw new Error(`Archive source cannot contain symbolic links: ${target}`);
+            if (stat.isDirectory())
+                walk(target);
+            else if (stat.isFile()) {
+                if (entry.name !== 'contents.sha256')
+                    files.push(target);
+            }
+            else
+                throw new Error(`Archive source cannot contain special files: ${target}`);
+        }
+    };
+    walk(localDir);
+    const rows = files
+        .map((file) => ({ file, relative: path.relative(localDir, file).split(path.sep).join('/') }))
+        .sort((left, right) => Buffer.compare(Buffer.from(left.relative), Buffer.from(right.relative)))
+        .map(({ file, relative }) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${relative}`);
+    return `${rows.join('\n')}${rows.length ? '\n' : ''}`;
+}
+function writeArchiveContentsHash(localDir) {
+    const contents = archiveContentsHash(localDir);
+    const hashPath = path.join(localDir, 'contents.sha256');
+    const tempPath = path.join(localDir, `.contents.sha256.${process.pid}.${Math.random().toString(36).slice(2)}.tmp`);
+    try {
+        fs.writeFileSync(tempPath, contents, { flag: 'wx' });
+        fs.renameSync(tempPath, hashPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function restoreArchivedTask(taskMdPath, contents, mode) {
+    const tempPath = `${taskMdPath}.${process.pid}.${Math.random().toString(36).slice(2)}.rollback`;
+    fs.writeFileSync(tempPath, contents, { flag: 'wx', mode });
+    try {
+        fs.renameSync(tempPath, taskMdPath);
+    }
+    catch (error) {
+        try {
+            fs.unlinkSync(tempPath);
+        }
+        catch (cleanupError) {
+            if (cleanupError.code !== 'ENOENT') {
+                throw new Error(`${error instanceof Error ? error.message : String(error)}; failed to remove ${tempPath}: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
+            }
+        }
+        throw error;
+    }
+}
+function writeTask(request, options = {}) {
+    const resolved = options.taskLocation
+        ? {
+            ok: true,
+            repoRoot: options.taskLocation.repoRoot,
+            taskId: options.taskLocation.taskId,
+            taskDir: path.dirname(options.taskLocation.taskMdPath),
+            taskMdPath: options.taskLocation.taskMdPath,
+            state: options.taskLocation.state
+        }
+        : resolveTaskRef(request.taskRef, { repoRoot: options.repoRoot });
+    if (!resolved.ok) {
+        return failure(request, { taskId: resolved.taskId, taskMdPath: null, actualState: null }, resolved.code, resolved.message);
+    }
+    if (resolved.state !== 'archive' || request.expectedState !== 'archive' || request.dryRun) {
+        return writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+    }
+    const identity = { taskId: resolved.taskId, taskMdPath: resolved.taskMdPath, actualState: resolved.state };
+    try {
+        const originalTask = fs.readFileSync(resolved.taskMdPath);
+        const originalMode = fs.statSync(resolved.taskMdPath).mode;
+        archiveContentsHash(resolved.taskDir);
+        const result = writeTaskCore(request, { ...options, taskLocation: {
+                repoRoot: resolved.repoRoot,
+                taskId: resolved.taskId,
+                taskMdPath: resolved.taskMdPath,
+                state: resolved.state
+            } });
+        if (result.status === 'applied') {
+            try {
+                writeArchiveContentsHash(resolved.taskDir);
+            }
+            catch (error) {
+                try {
+                    restoreArchivedTask(resolved.taskMdPath, originalTask, originalMode);
+                }
+                catch (rollbackError) {
+                    throw new Error(`Archive checksum update failed: ${error instanceof Error ? error.message : String(error)}; task rollback failed: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`);
+                }
+                throw error;
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        return failure(request, identity, 'TASK_READ_FAILED', error instanceof Error ? error.message : String(error));
+    }
+}
 export { writeTask, captureTaskWriteMetadata, canonicalTimestamp };
 //# sourceMappingURL=write.js.map

package/dist/lifecycle-build-manifest.json

@@ -1,6 +1,6 @@
 {
   "protocolVersion": 3,
-  "packageVersion": "0.11.5",
-  "sourceInputHash": "2f29b7f1f134733c3bc1bb7c92ea6c11e57462ed51a5a96b0198b8824a3f455d",
-  "internalExecutableBuildHash": "cb9d00aa3fa974cf936a8aad310e1fa5f28842351f52a53fed43345fe9c46439"
+  "packageVersion": "0.11.7",
+  "sourceInputHash": "095f0cf30aa29fcd2dd45123dc755e5097d7a9f81de33420461fd943cff122b2",
+  "internalExecutableBuildHash": "a956f2ed366e025a111a87bc1f542b87d83d4025e068304f95b1aae704709d3f"
 }

package/lib/git/primary-worktree.ts

@@ -0,0 +1,62 @@
+import { execFileSync } from 'node:child_process';
+import fs from 'node:fs';
+
+import { sameFilesystemEntry } from './worktree-identity.ts';
+
+function gitText(repositoryRoot: string, args: string[]): string {
+  return execFileSync('git', ['-C', repositoryRoot, ...args], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  }).replace(/\r?\n$/, '');
+}
+
+function isPrimaryWorktree(candidate: string, expectedCommonDirectory: string): boolean {
+  try {
+    const root = fs.realpathSync.native(candidate);
+    if (!fs.statSync(root).isDirectory()) return false;
+    if (gitText(root, ['rev-parse', '--show-prefix']) !== '') return false;
+
+    const commonDirectory = gitText(root, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    const gitDirectory = gitText(root, ['rev-parse', '--absolute-git-dir']);
+    return sameFilesystemEntry(commonDirectory, expectedCommonDirectory) &&
+      sameFilesystemEntry(gitDirectory, expectedCommonDirectory);
+  } catch {
+    return false;
+  }
+}
+
+function worktreePaths(repositoryRoot: string): string[] {
+  const output = execFileSync('git', ['-C', repositoryRoot, 'worktree', 'list', '--porcelain', '-z'], {
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+
+  return output
+    .split('\0\0')
+    .flatMap((record) => record.split('\0'))
+    .filter((field) => field.startsWith('worktree '))
+    .map((field) => field.slice('worktree '.length));
+}
+
+export function resolvePrimaryWorktreeRoot(repositoryRoot: string): string {
+  try {
+    const root = fs.realpathSync.native(repositoryRoot);
+    if (!fs.statSync(root).isDirectory() || gitText(root, ['rev-parse', '--show-prefix']) !== '') {
+      throw new Error('repository root is not a worktree root');
+    }
+
+    const commonDirectory = gitText(root, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
+    const gitDirectory = gitText(root, ['rev-parse', '--absolute-git-dir']);
+    if (sameFilesystemEntry(gitDirectory, commonDirectory)) return root;
+
+    const matches = worktreePaths(root).filter((candidate) => isPrimaryWorktree(candidate, commonDirectory));
+    if (matches.length !== 1) {
+      throw new Error(matches.length === 0 ? 'primary worktree metadata was not found' : 'primary worktree metadata is ambiguous');
+    }
+
+    return fs.realpathSync.native(matches[0]!);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(`server: unable to locate primary worktree: ${detail}`);
+  }
+}

package/lib/merge.ts

@@ -1,5 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import crypto from 'node:crypto';
 import { removeDirRecursive } from './remove-dir.ts';
 import { validateCurrentTaskContract } from './task/current-contract.ts';
 
@@ -107,7 +108,7 @@ function extractTitle(content: string): string | null {
 }
 
 function normalizeTaskRecord(taskDir: string, taskFile: string, dateParts: DateParts): TaskRecord {
-  const taskId = path.basename(taskDir);
+  const taskId = path.basename(taskDir) === 'local' ? path.basename(path.dirname(taskDir)) : path.basename(taskDir);
   const content = fs.readFileSync(taskFile, 'utf8');
   const completedAt = extractField(content, 'completed_at');
   const updatedAt = extractField(content, 'updated_at');
@@ -155,7 +156,7 @@ function scanSourceTasks(sourceDir: string): TaskRecord[] {
             continue;
           }
 
-          const taskDir = path.join(dayDir, taskEntry.name);
+          const taskDir = path.join(dayDir, taskEntry.name, 'local');
           const taskFile = path.join(taskDir, 'task.md');
           if (!fs.existsSync(taskFile)) {
             continue;
@@ -251,7 +252,7 @@ function collectArchiveEntries(archiveDir: string): ArchiveManifestEntry[] {
           }
 
           const taskDir = path.join(dayDir, taskEntry.name);
-          const taskFile = path.join(taskDir, 'task.md');
+          const taskFile = path.join(taskDir, 'local', 'task.md');
           const relativePath = `${yearEntry.name}/${monthEntry.name}/${dayEntry.name}/${taskEntry.name}/`;
           let title = taskEntry.name;
           let type = 'unknown';
@@ -624,10 +625,12 @@ function validateSourceRoot(sourceRoot: string): void {
 function validateTaskDirectory(
   sourceRoot: string,
   taskDir: string,
-  seenTaskIds: Map<string, string>
+  seenTaskIds: Map<string, string>,
+  archived = false
 ): void {
   const taskId = path.basename(taskDir);
-  const taskFile = path.join(taskDir, 'task.md');
+  const contentDir = archived ? path.join(taskDir, 'local') : taskDir;
+  const taskFile = path.join(contentDir, 'task.md');
   const taskDirStat = sourcePathStat(sourceRoot, taskDir);
   if (!taskDirStat || !taskDirStat.isDirectory()) {
     invalidSource(`${sourceRelativePath(sourceRoot, taskDir)} must be a directory`);
@@ -646,6 +649,33 @@ function validateTaskDirectory(
     invalidSource(`${sourceRelativePath(sourceRoot, taskFile)} id '${String(contract.metadata.id ?? 'missing')}' does not match directory '${taskId}'`);
   }
   validateTaskTree(sourceRoot, taskDir);
+  if (archived) {
+    for (const entry of fs.readdirSync(taskDir, { withFileTypes: true })) {
+      if (!['local', 'github', 'derived'].includes(entry.name) || !entry.isDirectory()) {
+        invalidSource(`${sourceRelativePath(sourceRoot, path.join(taskDir, entry.name))} is not an allowed archive source directory`);
+      }
+    }
+    validateArchiveSource(sourceRoot, contentDir);
+    const githubDir = path.join(taskDir, 'github');
+    if (fs.existsSync(githubDir)) {
+      for (const capture of fs.readdirSync(githubDir, { withFileTypes: true })) {
+        const captureDir = path.join(githubDir, capture.name);
+        if (!capture.isDirectory() || !/^capture-[A-Za-z0-9._-]+$/.test(capture.name) || !fs.existsSync(path.join(captureDir, 'capture.md'))) {
+          invalidSource(`${sourceRelativePath(sourceRoot, captureDir)} is not a valid GitHub capture`);
+        }
+        validateArchiveSource(sourceRoot, captureDir);
+      }
+    }
+    const derivedDir = path.join(taskDir, 'derived');
+    if (fs.existsSync(derivedDir)) {
+      for (const view of fs.readdirSync(derivedDir, { withFileTypes: true })) {
+        const viewDir = path.join(derivedDir, view.name);
+        if (!view.isDirectory() || !fs.existsSync(path.join(viewDir, 'inputs.md'))) {
+          invalidSource(`${sourceRelativePath(sourceRoot, viewDir)} requires inputs.md`);
+        }
+      }
+    }
+  }
 
   const previousPath = seenTaskIds.get(taskId);
   if (previousPath) {
@@ -654,6 +684,26 @@ function validateTaskDirectory(
   seenTaskIds.set(taskId, sourceRelativePath(sourceRoot, taskDir));
 }
 
+function validateArchiveSource(sourceRoot: string, sourceDir: string): void {
+  const hashFile = path.join(sourceDir, 'contents.sha256');
+  const hashStat = sourcePathStat(sourceRoot, hashFile);
+  if (!hashStat?.isFile()) invalidSource(`${sourceRelativePath(sourceRoot, sourceDir)} requires contents.sha256`);
+  const files: string[] = [];
+  const walk = (dir: string) => {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      const target = path.join(dir, entry.name);
+      if (entry.name === 'manifest.md') invalidSource(`${sourceRelativePath(sourceRoot, target)} is forbidden inside a TASK`);
+      if (entry.isDirectory()) walk(target);
+      else if (entry.isFile() && target !== hashFile) files.push(target);
+    }
+  };
+  walk(sourceDir);
+  const expected = files.sort((a, b) => Buffer.compare(Buffer.from(path.relative(sourceDir, a).split(path.sep).join('/')), Buffer.from(path.relative(sourceDir, b).split(path.sep).join('/'))))
+    .map((file) => `${crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex')}  ${path.relative(sourceDir, file).split(path.sep).join('/')}`);
+  const actual = fs.readFileSync(hashFile, 'utf8').trimEnd().split(/\r?\n/).filter(Boolean);
+  if (JSON.stringify(expected) !== JSON.stringify(actual)) invalidSource(`${sourceRelativePath(sourceRoot, hashFile)} does not match local files`);
+}
+
 function validateMutableSection(
   sourceRoot: string,
   section: MutableSection,
@@ -730,9 +780,6 @@ function validateArchiveSection(
       const monthDir = monthPath;
       for (const dayEntry of fs.readdirSync(monthDir, { withFileTypes: true })) {
         const dayPath = path.join(monthDir, dayEntry.name);
-        if (allowManifest(monthDir, dayEntry)) {
-          continue;
-        }
         const dayStat = sourcePathStat(sourceRoot, dayPath);
         if (!dayStat?.isDirectory() || !/^\d{2}$/.test(dayEntry.name)) {
           invalidSource(`${sourceRelativePath(sourceRoot, dayPath)} is not a DD directory or manifest.md`);
@@ -745,7 +792,7 @@ function validateArchiveSection(
           if (!taskStat?.isDirectory() || !TASK_ID_RE.test(taskEntry.name)) {
             invalidSource(`${sourceRelativePath(sourceRoot, taskPath)} is not a TASK-YYYYMMDD-HHMMSS directory`);
           }
-          validateTaskDirectory(sourceRoot, taskPath, seenTaskIds);
+          validateTaskDirectory(sourceRoot, taskPath, seenTaskIds, true);
         }
       }
     }
@@ -904,9 +951,10 @@ function mergeArchiveSection(sourceArchive: string, localArchive: string, report
       continue;
     }
 
+    const sourceTaskDir = path.dirname(task.taskDir);
     const destinationDir = path.join(localArchive, task.relativePath);
     fs.mkdirSync(path.dirname(destinationDir), { recursive: true });
-    fs.cpSync(task.taskDir, destinationDir, { recursive: true });
+    fs.cpSync(sourceTaskDir, destinationDir, { recursive: true });
     recordArchive(report, 'copied', {
       action: 'copied',
       symbol: '✓',
@@ -1045,6 +1093,7 @@ async function cmdMerge(args: string[]): Promise<void> {
   const report = createReport(resolvedSource, backupRootRelative);
   detectSourceMode(resolvedSource);
   validateSourceWorkspace(resolvedSource);
+  validateArchiveSection(workspaceDir, new Map());
 
   for (const section of ALL_SECTIONS) {
     fs.mkdirSync(path.join(workspaceDir, section), { recursive: true });

package/lib/platform/github-provider.ts

@@ -923,30 +923,23 @@ function createGitHubOperations(client: GitHubClient): Pick<PlatformProvider, 'i
       if (collected.status === 'failed' || collected.status === 'blocked' || !('pullRequests' in collected)) {
         return { ok: false, error: collected.error || { code: 'RELEASE_NOTES_COLLECTION_FAILED', message: 'Release notes could not be collected', retryable: false } };
       }
-      const mergedPullRequests = collected.pullRequests.map((item: any): ChangeRequestSnapshot => ({
-        id: String(item.number), identity: { kind: 'number', value: Number(item.number) }, number: Number(item.number),
-        state: 'closed', title: String(item.title || ''), body: String(item.body || ''),
+      const mergedPullRequests = collected.pullRequests.map((item: any) => ({
+        id: String(item.number), identity: { kind: 'number' as const, value: Number(item.number) }, number: Number(item.number),
+        title: String(item.title || ''), body: String(item.body || ''),
         mergedAt: new Date(String(item.mergedAt)).toISOString(), displayUrl: String(item.url || ''),
         labels: Array.isArray(item.labels) ? item.labels.map((label: any) => String(label.name || label)) : [],
-        assignees: [], mergeCommitSha: null
-      }));
-      const closingIssues: IssueSnapshot[] = collected.pullRequests.flatMap((item: any) =>
-        Array.isArray(item.closingIssuesReferences) ? item.closingIssuesReferences.map((issue: any) => ({
+        author: item.author,
+        closingIssues: item.closingIssues.map((issue: any) => ({
           id: String(issue.number), identity: { kind: 'number', value: Number(issue.number) }, number: Number(issue.number),
-          state: 'closed' as const, title: String(issue.title || ''), body: '', labels: Array.isArray(issue.labels) ? issue.labels.map((label: any) => String(label.name || label)) : [],
-          assignees: [], milestone: null, fields: {}, displayUrl: String(issue.url || '')
-        })) : []
-      );
-      const actors = [...collected.authors.values()].flatMap((items) => items.map((item: any) => ({
-        ...(item.login ? { id: String(item.login) } : {}), ...(item.name ? { name: String(item.name) } : {})
-      })));
+          title: String(issue.title || ''), displayUrl: String(issue.url || ''), author: issue.author
+        }))
+      }));
       return {
         ok: true,
         value: {
-          history: commitOids.map((sha) => ({ sha, message: '', authoredAt: toTime, author: actors.find((actor) => actor.id) || null })),
+          history: collected.history,
+          commits: collected.commits,
           mergedPullRequests,
-          closingIssues,
-          actors
         }
       };
     }
@@ -1116,7 +1109,7 @@ function createGitHubProvider(
 ): PlatformProvider {
   return {
     type: input.providerType,
-    contractVersion: 1,
+    contractVersion: 2,
     identity: { issue: 'number', 'pull-request': 'number', comment: 'number', release: 'key' },
     ...createGitHubOperations(client),
     context: {