software-defence-factory 0.11.1 → 0.12.0

package/README.md

@@ -45,7 +45,7 @@ The runtime supplies policy and six focused skills to its isolated jobs. `init`
 
 Each result belongs to a specific candidate commit and policy. A failed check blocks delivery. Changing the candidate or check policy invalidates earlier evidence. Approval records a handoff; publishing, merging and deployment follow the application's separate authority.
 
-The project dashboard has an **Inbox**, measured **Analytics**, **Agents**, **Skills**, **Automations**, **Definition** and **Infrastructure**. Inbox lists repository issues with readiness and linked execution attempts. New issue offers repository templates or a blank creation form. Create an issue on the supported repository provider, then choose Start work separately; local brief execution remains available. CLI `issue` exposes the same intake. Definition lives with settings above the theme control. The CLI reads the same definition and controller state. Agent roles use a selected harness such as Codex or Pi; a worker executes their isolated jobs on a host. See [concepts](docs/concepts.md) and [supported interfaces](docs/interfaces.md). Optional automations belong to the selected harness, which calls Factory CLI/API. Factory runs no cron scheduler. See [provider boundaries](docs/integrations.md).
+The project dashboard has an **Inbox**, measured **Analytics**, **Agents**, **Skills**, **Automations**, **Definition** and **Infrastructure**. Inbox opens on a shared list/board of loaded repository issues and local work, with status, search and checkbox filters, readiness and linked execution attempts. New issue offers repository templates or a blank creation form. Create an issue on the supported repository provider, then choose Start work separately; local brief execution remains available. CLI `issue` exposes the same intake. Definition lives with settings above the theme control. The CLI reads the same definition and controller state. Agent roles use a selected harness such as Codex or Pi; a worker executes their isolated jobs on a host. See [concepts](docs/concepts.md) and [supported interfaces](docs/interfaces.md). Optional automations belong to the selected harness, which calls Factory CLI/API. Factory runs no cron scheduler. See [provider boundaries](docs/integrations.md).
 
 The optional **defence** workflow accepts scoped incident evidence and produces a private, read-only draft. It does not monitor production or claim verified recovery. See [defence integration](docs/defence-integration.md).
 

package/docs/concepts.md

@@ -18,8 +18,10 @@ The CLI `definition` command and dashboard Definition page read that same catalo
 | Automation | External schedule and agent context | Owned by the selected harness; calls Factory CLI/API, no Factory cron |
 | Definition | Effective roles, workflows, skills and settings | Installed method plus private factory.json; read-only catalog |
 
-Inbox contains execution history, not a copied remote issue backlog. New issue
-can create a repository issue without execution; Start work admits execution
+Inbox combines an explicitly loaded provider page with retained execution
+history in one list/board, grouped by canonical issue identity. Off-page sources
+remain unknown; local requests keep separate identities. New issue
+creates a repository issue without execution; Start work admits execution
 separately. The provider owns issue content/state; SQLite owns queue/attempts and
 creation receipts for recovery. An unfinished local form is not a saved backlog.
 An agent role is neither a machine nor a skill. Check is deterministic, and

package/docs/interfaces.md

@@ -11,7 +11,7 @@ shell endpoint or a second scheduler.
 | --- | --- | --- | --- | --- |
 | Project/queue/attempt state | `status`, `inbox --source factory` JSON | `GET /api/v1/status` | Project, tasks, details/history | Stable versioned agent result/error contract |
 | Start local work | `issue start --file --title` or `--draft`, explicit `--workflow`, optional `--model` | `POST /api/v1/jobs` | Local execution only → review → Create & start locally | Persistent unstarted drafts and typed incident intake remain separate |
-| Browse repository Inbox | `inbox [--page N] [--issue-state open/closed/all]` (also `issue list --source inbox`), `issue preview --url URL` via controller provider | Authenticated `GET /api/v1/issues`, `POST /api/v1/issues/preview` using shared readers | Inbox with provider/state/readiness, loaded-page counts, linked attempts, local/off-page history; explicit Start work for either type | Issue → execution links retained; no implicit polling |
+| Browse repository Inbox | `inbox [--page N] [--issue-state open/closed/all]` (also `issue list --source inbox`), `issue preview --url URL` via controller provider | Authenticated `GET /api/v1/issues`, `POST /api/v1/issues/preview` using shared readers | Primary list/Board with shared status/search/workflow/model/label filters, compact Repository tools/loaded scope, item count with secondary issue/execution totals and progressive linked detail; explicit Start work for either type | Issue → execution links retained; no implicit polling |
 | Start repository work | `issue start --url URL --workflow software/defence [--brief-file operator.md]` | `POST /api/v1/issues/start` | Issue context → explicit Start work with operator brief | Rechecks current content and active admission |
 | Create repository issue / recovery | `issue connection`, `create --key`, `submissions`, `recover --key` | Authenticated connection, `POST /issues`, receipts and recovery | Display destination/actor, create without execution, recover uncertain result | GitHub adapter first; assignees/projects and other providers unimplemented |
 | Repository issue templates | `issue templates`, `issue draft --template --sha --file` | Authenticated template list and draft compilation | Chooser, fields/defaults/validation, review | Supports Markdown and YAML markdown/input/textarea/dropdown/checkboxes; unsupported templates link to GitHub |
@@ -106,3 +106,25 @@ Definition exposes `configuration.issueReadinessLabels`. The optional private
 config field has exactly triage/spec/ready/blocked keys with four distinct label
 names; defaults are factory:triage/spec/ready/blocked. Configuration is validated,
 not inferred from issue content. No browsing path changes labels or comments.
+
+The additive `work_records` read model is returned by `GET /api/v1/issues`
+(and CLI `inbox` / `issue list --source inbox`) alongside the existing `issues`
+and `history` fields. `status` returns the same model for retained history without
+fetching a provider page. Each record includes a canonical `key`, source `identity`,
+`source_status` (`loaded`, `not_loaded`, `local`), optional source `issue`, all
+`executions`, representative `execution_id`, actual `state`, `workflow` and `phase`.
+Active/unresolved execution takes precedence over the latest terminal execution.
+Without an execution, state is `not_started`, workflow/phase and execution ID are
+null. Readiness lives on the source issue, separate from execution state. Dashboard
+projection uses this same pure read-model function with its bounded page snapshot
+and latest status; grouping/filtering does not admit execution. Individual
+`#/runs/JOB_ID` links remain valid; `#/issues/KEY` opens canonical source detail.
+
+The dashboard's Repository disclosure beside the item count holds source-state
+selection, refresh, available previous/next page actions and Local execution
+request. It also explains read time, remote total, the loaded search boundary
+and separate issue/local request/execution counts. Loading and source errors
+remain visible when it is closed. Rows and cards share compact metadata; source
+readiness remains distinct from the runtime badge, and full assignments and
+linked attempts remain in detail. These presentation controls do not change
+headless records or admission semantics.

package/docs/npm.md

@@ -104,8 +104,8 @@ installation or retained attempt needs them.
 
 ## Protected evidence compatibility
 
-Factory 0.11.1 recognizes version-1 execution profiles emitted by native
-**0.8.0, 0.9.0, 0.9.1, 0.10.0, 0.11.0 and 0.11.1**. This is an exact allowlist in
+Factory 0.12.0 recognizes version-1 execution profiles emitted by native
+**0.8.0, 0.9.0, 0.9.1, 0.10.0, 0.11.0, 0.11.1, 0.11.2 and 0.12.0**. This is an exact allowlist in
 `factory/execution-profile.mjs`, independent of the installed package version;
 it is not a semver range or an automatic promise for later releases. Unknown
 runtime strings, unknown profile formats and incomplete legacy acceptance
@@ -143,6 +143,16 @@ a checkpoint usable. Browser-disabled 0.8.0 records cannot satisfy a newly
 enabled browser policy. Missing or unsupported records stay unchanged and
 unavailable; no schema migration, profile relabeling or policy repair occurs.
 
+Version 0.11.2 retains the v1 profile/evidence schema and current provenance
+rules while preserving exact patch bytes and requiring reconstruction before
+new acceptance. Older writers remain compatible only when their retained patch
+passes the current digest and tree reconstruction checks. A digest-matching
+malformed patch remains blocked and unchanged; follow the [recovery guidance](recovery.md#already-accepted-malformed-patches-91).
+
+Version 0.12.0 adds the all-work Inbox read model and restores the retained
+overview. Protected execution writers and acceptance/publication guards are
+unchanged; the explicit compatible-writer entry preserves all checks above.
+
 New publication still requires the current remote target to equal the original
 accepted base; reviewed-candidate continuation preserves that baseline, while
 target refresh remains #72. See [the verification map](https://github.com/arcitai/software-and-defence-factory/blob/main/docs/proof.md) for delivered

package/docs/recovery.md

@@ -332,6 +332,27 @@ approval; do not edit SQLite or acceptance evidence to bypass the guard. A stale
 target after branch creation leaves that unique branch for inspection and does
 not open a PR. A PR does not imply integration or deployment.
 
+## Already accepted malformed patches (#91)
+
+A matching digest does not prove a patch can reproduce its candidate. Before
+0.11.2, trimming Git diff output could remove trailing blank context lines.
+Native publication correctly refuses such a patch before provider writes.
+Preserve the accepted record, patch, digests, retained Git objects and prior
+attempts. Restarting or reading state does not repair or migrate this evidence.
+
+For recovery, use a separately reviewed, normal protected maintainer PR from
+the exact retained candidate tree, checking its tree identity and original base,
+or run a new native attempt with fresh Verify, independent Review and approval.
+The maintainer route is not successful native publication. Never replace an old
+patch or acceptance hash, fabricate approval, or disable reconstruction guards.
+
+New handoffs in 0.11.2 retain raw Git bytes and reconstruct the protected patch
+against the original retained base in private bare storage before acceptance.
+Failure retains evidence and creates no accepted record or provider writes.
+Publication still repeats reconstruction and all current provenance, source,
+workflow and target checks. Operator installed/native qualification on Z13 is
+required before further general unattended delivery.
+
 ## Continue a reviewed candidate (first #42 slice)
 
 Use one explicit starting point for a current software review with a returned

package/docs/workflows.md

@@ -24,7 +24,9 @@ kept outside those execution mounts.
 
 ## Start work
 
-Inbox lists repository issues directly. Choose Open, Closed or All states and use
+Inbox opens on the shared list/Board of repository issues and local work, with
+status rail and workflow/model/status/label multiselects. Never-started issues
+have unknown workflow/model and a distinct Not started state. Choose Open, Closed or All states and use
 Previous/Next page or Refresh issues. Search covers the loaded page and visible
 history, not the whole repository. GitHub returns up to 50 records per page;
 pull requests are excluded, so even a page with zero issues can have a next page.
@@ -146,4 +148,7 @@ non-issue paths are not admitted by the provider preview. Local-only records and
 executions whose source is missing, closed or outside the loaded page remain in
 Local and other execution history. Removing local execution history preserves
 private evidence and never deletes a provider issue; unresolved delivery guards
-still apply. The separate Execution history tab keeps the execution list/board.
+still apply. The primary list/board includes all these records; no separate
+Execution history tab is needed. Its count line distinguishes issue identities
+and individual executions. Open a record for progressive context and every
+linked attempt; close/Escape returns to the preserved filters, view and scroll.

package/factory/candidate-patch.mjs

@@ -0,0 +1,73 @@
+import { assertPrivateDirectory } from './execution-evidence.mjs';
+import { lstatSync, mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { join } from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { digest } from './lib.mjs';
+
+const MAX_PATCH_BYTES = 8 * 1024 * 1024;
+const MAX_TREE_BYTES = 8 * 1024 * 1024;
+
+function readPrivateFile(path, limit) {
+  const stat = lstatSync(path);
+  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0 || stat.size > limit)
+    throw new Error('Protected candidate patch is missing, unsafe or too large.');
+  return readFileSync(path);
+}
+function runGitCommand(args) {
+  const env = {
+    PATH: process.env.PATH || '/usr/bin:/bin', HOME: '/nonexistent',
+    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0',
+  };
+  const result = spawnSync('git', args, { env, encoding: 'utf8', maxBuffer: MAX_TREE_BYTES + MAX_PATCH_BYTES + 1024 * 1024 });
+  if (result.error || result.status !== 0) throw new Error('Could not prepare private candidate reconstruction storage.');
+  return result.stdout.trim();
+}
+function runGit(repo, args, { input, binary = false } = {}) {
+  // Delivery reconstruction runs only trusted Git operations in a newly made
+  // bare repository. Candidate hooks, filters, global config and credentials
+  // are unavailable to these subprocesses.
+  const env = {
+    PATH: process.env.PATH || '/usr/bin:/bin',
+    HOME: '/nonexistent',
+    GIT_CONFIG_NOSYSTEM: '1',
+    GIT_CONFIG_GLOBAL: '/dev/null',
+    GIT_TERMINAL_PROMPT: '0',
+    GIT_OPTIONAL_LOCKS: '0',
+  };
+  const result = spawnSync('git', ['--git-dir', repo, '-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', ...args], {
+    env, input, encoding: binary ? null : 'utf8', maxBuffer: MAX_TREE_BYTES + MAX_PATCH_BYTES + 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) throw new Error('Could not reconstruct the accepted candidate from retained Git objects.');
+  return binary ? result.stdout : result.stdout.trim();
+}
+// Shared acceptance/publication boundary. Only the original retained base and
+// exact protected patch bytes enter new, private bare storage. The callback may
+// inspect reconstructed objects; cleanup removes only this invocation's scratch.
+export function withReconstructedCandidate({ state, jobId, sourcePath, objectFormat, candidate }, inspect = () => {}) {
+  const oid = new RegExp(`^[a-f0-9]{${objectFormat === 'sha256' ? 64 : 40}}$`);
+  if (!['sha1', 'sha256'].includes(objectFormat) || !oid.test(candidate.base || '') || !oid.test(candidate.tree || ''))
+    throw new Error('Candidate has an unsupported Git object identity.');
+  const folder = join(state, 'jobs', jobId);
+  const patchPath = join(folder, 'delivery-input', 'candidate.patch');
+  assertPrivateDirectory(join(state, 'jobs'));
+  assertPrivateDirectory(folder);
+  assertPrivateDirectory(join(folder, 'delivery-input'));
+  const patch = readPrivateFile(patchPath, MAX_PATCH_BYTES);
+  if (!patch.length || digest(patch) !== candidate.patch_sha256) throw new Error('Accepted patch digest does not match the approval record.');
+  const scratchRoot = mkdtempSync(join(folder, 'delivery-work-'));
+  const repo = join(scratchRoot, 'candidate.git');
+  try {
+    runGitCommand(['init', '--bare', '--quiet', '--template=', `--object-format=${objectFormat}`, repo]);
+    runGit(repo, ['fetch', '--quiet', '--no-tags', '--', sourcePath, `${candidate.base}:refs/heads/factory-base`]);
+    if (runGit(repo, ['rev-parse', '--verify', `${candidate.base}^{commit}`]) !== candidate.base)
+      throw new Error('Accepted base differs from the retained source commit.');
+    runGit(repo, ['read-tree', candidate.base]);
+    runGit(repo, ['apply', '--cached', '--binary', '--whitespace=nowarn', '-'], { input: patch });
+    const tree = runGit(repo, ['write-tree']);
+    if (tree !== candidate.tree) throw new Error('Protected patch does not reproduce the accepted candidate tree.');
+    return inspect({ repo, patch, tree, git: runGit });
+  } finally {
+    rmSync(scratchRoot, { recursive: true, force: true });
+  }
+}

package/factory/delivery.mjs

@@ -1,8 +1,8 @@
-import { readPrivateJson, assertPrivateDirectory, trustedExecutionProfile } from './execution-evidence.mjs';
+import { withReconstructedCandidate } from './candidate-patch.mjs';
+import { readPrivateJson, trustedExecutionProfile } from './execution-evidence.mjs';
 import { createHash, randomBytes } from 'node:crypto';
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { spawnSync } from 'node:child_process';
 import { configAt, digest } from './lib.mjs';
 import { effectiveExecutionConfig, isSupportedExecutionProfile } from './execution-profile.mjs';
 import { publicSourceAdmission } from './source-admission.mjs';
@@ -11,7 +11,6 @@ import { readProjectLinks } from './project-links.mjs';
 import { qualifyGitHubActions } from './workflow-qualification.mjs';
 import { assertCurrentWebEvidence, assertCurrentWebArtifacts } from './web-verification.mjs';
 
-const MAX_PATCH_BYTES = 8 * 1024 * 1024;
 const MAX_CHANGED_FILES = 500;
 const MAX_TREE_BYTES = 8 * 1024 * 1024;
 const SHA1 = /^[a-f0-9]{40}$/;
@@ -39,7 +38,6 @@ class BranchCollisionError extends QueueError {
   }
 }
 
-function sha256(value) { return createHash('sha256').update(value).digest('hex'); }
 function utcGitDate(value) {
   const parsed = new Date(value);
   if (!Number.isFinite(parsed.getTime())) throw new Error('Accepted timestamp is invalid.');
@@ -54,40 +52,6 @@ function commitObjectSha({ tree, parents, message, author, committer }) {
   const raw = Buffer.from(`tree ${tree}\nparent ${parents[0]}\nauthor ${author.name} <${author.email}> ${date.epoch} +0000\ncommitter ${committer.name} <${committer.email}> ${date.epoch} +0000\n\n${message}`, 'utf8');
   return createHash('sha1').update(`commit ${raw.length}\0`).update(raw).digest('hex');
 }
-function readPrivateFile(path, limit) {
-  const stat = lstatSync(path);
-  if (!stat.isFile() || stat.isSymbolicLink() || (stat.mode & 0o077) !== 0 || stat.size > limit)
-    throw new Error('Protected candidate patch is missing, unsafe or too large.');
-  return readFileSync(path);
-}
-function runGitCommand(args) {
-  const env = {
-    PATH: process.env.PATH || '/usr/bin:/bin', HOME: '/nonexistent',
-    GIT_CONFIG_NOSYSTEM: '1', GIT_CONFIG_GLOBAL: '/dev/null',
-    GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0',
-  };
-  const result = spawnSync('git', args, { env, encoding: 'utf8', maxBuffer: MAX_TREE_BYTES + MAX_PATCH_BYTES + 1024 * 1024 });
-  if (result.error || result.status !== 0) throw new Error('Could not prepare private candidate reconstruction storage.');
-  return result.stdout.trim();
-}
-function runGit(repo, args, { input, binary = false } = {}) {
-  // Delivery reconstruction runs only trusted Git operations in a newly made
-  // bare repository. Candidate hooks, filters, global config and credentials
-  // are unavailable to these subprocesses.
-  const env = {
-    PATH: process.env.PATH || '/usr/bin:/bin',
-    HOME: '/nonexistent',
-    GIT_CONFIG_NOSYSTEM: '1',
-    GIT_CONFIG_GLOBAL: '/dev/null',
-    GIT_TERMINAL_PROMPT: '0',
-    GIT_OPTIONAL_LOCKS: '0',
-  };
-  const result = spawnSync('git', ['--git-dir', repo, '-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', ...args], {
-    env, input, encoding: binary ? null : 'utf8', maxBuffer: MAX_TREE_BYTES + MAX_PATCH_BYTES + 1024 * 1024,
-  });
-  if (result.error || result.status !== 0) throw new Error('Could not reconstruct the accepted candidate from retained Git objects.');
-  return binary ? result.stdout : result.stdout.trim();
-}
 function parseTree(bytes) {
   const entries = new Map();
   let start = 0;
@@ -112,24 +76,8 @@ function parseTree(bytes) {
 function candidateTree(state, job, sourcePath, sourceAdmission, accepted, { branch, target }) {
   if (sourceAdmission.object_format !== 'sha1' || !SHA1.test(accepted.base || '') || !SHA1.test(accepted.tree || ''))
     throw new Error('GitHub delivery currently requires a SHA-1 candidate from the retained source repository.');
-  const patchPath = join(state, 'jobs', job.id, 'delivery-input', 'candidate.patch');
-  assertPrivateDirectory(join(state, 'jobs'));
-  assertPrivateDirectory(join(state, 'jobs', job.id));
-  assertPrivateDirectory(join(state, 'jobs', job.id, 'delivery-input'));
-  const patch = readPrivateFile(patchPath, MAX_PATCH_BYTES);
-  if (!patch.length || sha256(patch) !== accepted.patch_sha256) throw new Error('Accepted patch digest does not match the approval record.');
-  const folder = join(state, 'jobs', job.id);
-  const scratchRoot = mkdtempSync(join(folder, 'delivery-work-'));
-  const scratchRepo = join(scratchRoot, 'candidate.git');
-  try {
-    runGitCommand(['init', '--bare', '--quiet', '--object-format=sha1', scratchRepo]);
-    runGit(scratchRepo, ['fetch', '--quiet', '--no-tags', '--', sourcePath, `${accepted.base}:refs/heads/factory-base`]);
-    const baseCommit = runGit(scratchRepo, ['rev-parse', '--verify', `${accepted.base}^{commit}`]);
-    if (baseCommit !== accepted.base) throw new Error('Accepted base differs from the retained source commit.');
-    runGit(scratchRepo, ['read-tree', accepted.base]);
-    runGit(scratchRepo, ['apply', '--cached', '--binary', '--whitespace=nowarn', patchPath]);
-    const tree = runGit(scratchRepo, ['write-tree']);
-    if (tree !== accepted.tree) throw new Error('Protected patch does not reproduce the accepted candidate tree.');
+  return withReconstructedCandidate({ state, jobId: job.id, sourcePath,
+    objectFormat: sourceAdmission.object_format, candidate: accepted }, ({ repo: scratchRepo, patch, tree, git: runGit }) => {
     const baseTree = runGit(scratchRepo, ['rev-parse', `${accepted.base}^{tree}`]);
     const before = parseTree(runGit(scratchRepo, ['ls-tree', '-r', '-z', accepted.base], { binary: true }));
     const after = parseTree(runGit(scratchRepo, ['ls-tree', '-r', '-z', tree], { binary: true }));
@@ -159,9 +107,7 @@ function candidateTree(state, job, sourcePath, sourceAdmission, accepted, { bran
       entries.push({ path, mode: next.mode, type: 'blob', content });
     }
     return { patch, patch_sha256: accepted.patch_sha256, base_tree: baseTree, tree, entries, workflowQualification };
-  } finally {
-    rmSync(scratchRoot, { recursive: true, force: true });
-  }
+  });
 }
 
 function sourceIssue(job, repository) {

package/factory/execution-profile.mjs

@@ -7,12 +7,15 @@ import { effectiveInferenceProvider } from './model-environment.mjs';
 import { expectedWebStories, webPolicyHash } from './web-verification.mjs';
 
 // Audited v1 protected evidence writers: 0.8.0 (380f749), 0.9.0 (cdaadef),
-// 0.9.1, 0.10.0, 0.11.0 and 0.11.1 (unchanged protected evidence writers).
+// 0.9.1, 0.10.0, 0.11.0 and 0.11.1 (unchanged protected evidence writers),
+// 0.11.2 (exact patch bytes and pre-acceptance reconstruction; same v1 schema).
+// 0.12.0 restores the Inbox read model/presentation; protected writers and guards are unchanged.
+// Older writers still require exact patch/tree reconstruction before publication.
 // Deliberately independent of VERSION: a release bump is not
 // evidence compatibility. Re-audit this list for every trust-relevant writer,
 // isolation or validation change; remove versions whose guarantees no longer
 // satisfy current policy. See docs/npm.md. This predicate alone grants no trust.
-const SUPPORTED_EXECUTION_RUNTIMES_V1 = new Set(['0.8.0', '0.9.0', '0.9.1', '0.10.0', '0.11.0', '0.11.1']);
+const SUPPORTED_EXECUTION_RUNTIMES_V1 = new Set(['0.8.0', '0.9.0', '0.9.1', '0.10.0', '0.11.0', '0.11.1', '0.11.2', '0.12.0']);
 
 export function isSupportedExecutionProfile(profile) {
   return profile?.version === 1 && SUPPORTED_EXECUTION_RUNTIMES_V1.has(profile.runtimeVersion);

package/factory/executor.mjs

@@ -1,3 +1,4 @@
+import { withReconstructedCandidate } from './candidate-patch.mjs';
 import { harnessOf } from './lib.mjs';
 import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, lstatSync } from 'node:fs';
 import { join } from 'node:path';
@@ -7,7 +8,7 @@ import { incidentFor, validateReport } from './incident.mjs';
 import { BoundedLog } from './bounded-log.mjs';
 import { CodexUsageParser, emptyUsage, usageFields } from './usage.mjs';
 import { assertRetainedSource, publicSourceAdmission, publicContinuation, restoreBuildCheckout } from './source-admission.mjs';
-import { runCandidateGit } from './git-environment.mjs';
+import { runCandidateGit, runCandidateGitRaw } from './git-environment.mjs';
 import { selectedInferenceSecrets, writeSelectedModelEnvironment } from './model-environment.mjs';
 import { redactInferenceText, redactRetainedPhaseOutputs } from './inference-redaction.mjs';
 import { assertCurrentHandoffEvidence } from './execution-evidence.mjs';
@@ -293,8 +294,7 @@ try {
       source_admission: publicSourceAdmission(sourceAdmission) };
     save(join(folder,'candidate.json'),meta);
     save(join(output,'candidate.json'),meta);
-    const patchText = git('--no-pager', 'diff', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', meta.base, meta.head);
-    const patch = patchText ? `${patchText}\n` : '';
+    const patch = runCandidateGitRaw(workspace, '--no-pager', 'diff', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', meta.base, meta.head);
     writeFileSync(join(output,'change.patch'), patch);
     writeFileSync(join(output,'implementation.md'),safeRead(join(reports,'agent-report.md')));
   } else if (phase === 'verify') {
@@ -343,9 +343,8 @@ try {
     if (config.webVerification?.enabled) assertCurrentWebArtifacts(config.webVerification, checks.web_verification,
       join(folder, 'artifacts', checks.run_id));
     assertCurrentHandoffEvidence(meta, checks, review, policyHash, config, job);
-    const patchText = git('--no-pager', 'diff', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', meta.base, meta.head);
-    const patch = patchText ? `${patchText}\n` : '';
-    if (!patch) throw new Error('Candidate has no content changes to accept');
+    const patch = runCandidateGitRaw(workspace, '--no-pager', 'diff', '--binary', '--full-index', '--no-ext-diff', '--no-textconv', meta.base, meta.head);
+    if (!patch.length) throw new Error('Candidate has no content changes to accept');
     const patchHash = digest(patch);
     const deliveryInput = join(folder, 'delivery-input');
     mkdirSync(deliveryInput, { recursive: true, mode: 0o700 });
@@ -355,6 +354,9 @@ try {
       if (!stat.isFile() || stat.isSymbolicLink() || digest(readFileSync(deliveryPatch)) !== patchHash)
         throw new Error('A different protected candidate patch already exists');
     } else writeFileSync(deliveryPatch, patch, { mode: 0o600, flag: 'wx' });
+    const retained = assertRetainedSource(state, job, sourceAdmission);
+    withReconstructedCandidate({ state, jobId: job, sourcePath: retained.path,
+      objectFormat: sourceAdmission.object_format, candidate: { ...meta, patch_sha256: patchHash } });
     const sourceSha = meta.source_admission?.resolved_sha || 'Not recorded (legacy/unknown)';
     writeFileSync(join(output,'handoff.md'), `Accepted candidate ${meta.head} (tree ${meta.tree}), based on source ${sourceSha}.\nPatch handoff remains available. Optional PR delivery is a separate explicit operator action when configured.\nNo integration, merge, release or deployment performed.\nSee docs/quickstart.md for applying the reviewed change.patch to your own branch.\n`);
     save(join(folder,'accepted.json'), { base: meta.base, head: meta.head, tree: meta.tree, patch_sha256: patchHash,

package/factory/git-environment.mjs

@@ -16,11 +16,21 @@ export function runHostGit(args, options = {}) {
   return run('git', args, { ...options, env: hostGitEnvironment() });
 }
 
-export function runCandidateGit(workspace, ...args) {
+function candidateGit(workspace, args, options) {
   return runHostGit([
     '-c', 'core.hooksPath=/dev/null',
     '-c', 'core.fsmonitor=false',
     '-C', workspace,
     ...args,
-  ]);
+  ], options);
+}
+
+// Scalar queries retain their historical trimming. Byte-bearing output must
+// explicitly opt into Buffer stdout, with identical environment and limits.
+export function runCandidateGit(workspace, ...args) {
+  return candidateGit(workspace, args);
+}
+
+export function runCandidateGitRaw(workspace, ...args) {
+  return candidateGit(workspace, args, { encoding: null });
 }

package/factory/issue-intake.mjs

@@ -24,6 +24,13 @@ function issueLabels(labels = []) {
   return labels.map(label => ({name:label.name, color:/^[a-f0-9]{6}$/i.test(label.color || '') ? label.color.toLowerCase() : null}));
 }
 
+function issueMetadata(issue) {
+  const date = value => typeof value === 'string' && Number.isFinite(Date.parse(value)) ? value : null;
+  const author = issue.user?.login || issue.author?.login;
+  return { author: typeof author === 'string' ? author : null,
+    created_at: date(issue.created_at || issue.createdAt), updated_at: date(issue.updated_at || issue.updatedAt) };
+}
+
 export async function listIssues(repo, page = 1, read = githubRead, state = 'open') {
   if (!Number.isSafeInteger(page) || page < 1 || page > 10000) throw new Error('Issue page must be an integer between 1 and 10000.');
   if (!['open', 'closed', 'all'].includes(state)) throw new Error('Issue state must be open, closed or all.');
@@ -35,7 +42,7 @@ export async function listIssues(repo, page = 1, read = githubRead, state = 'ope
   const issues = result.filter(issue => !issue.pull_request).map(issue => {
     validateIssueURL(repository, issue.html_url);
     if (!Number.isSafeInteger(issue.number) || !issue.html_url.endsWith(`/issues/${issue.number}`) || typeof issue.title !== 'string' || !issue.title.trim()) throw new Error('GitHub returned an unexpected issue.');
-    return { number: issue.number, title: issue.title, url: issue.html_url, state: issue.state || 'unknown', labels: issueLabels(issue.labels) };
+    return { ...issueMetadata(issue), number: issue.number, title: issue.title, url: issue.html_url, state: issue.state || 'unknown', labels: issueLabels(issue.labels) };
   });
   return { repository, issues, next_page: result.length === 50 && page < 10000 ? page + 1 : null };
 }
@@ -46,7 +53,7 @@ export function validateIssueURL(repoURL, value) {
   if (!repoURL || identity.repository !== repoURL.toLowerCase()) throw new Error('Issue does not belong to this project’s configured GitHub origin.');
   return identity.url;
 }
-export async function readIssue(repo, url, read = url => githubRead(['issue', 'view', url, '--json', 'title,body,url,labels,state'])) {
+export async function readIssue(repo, url, read = url => githubRead(['issue', 'view', url, '--json', 'title,body,url,labels,state,author,createdAt,updatedAt'])) {
   const repoURL = readProjectLinks(repo)?.repository;
   url = validateIssueURL(repoURL, url);
   const issue = await read(url);
@@ -55,5 +62,5 @@ export async function readIssue(repo, url, read = url => githubRead(['issue', 'v
   const spec = `Issue: ${issue.url}\n${issue.title}\n\n${issue.body}`;
   if (Buffer.byteLength(spec) > 240000) throw new Error('Issue exceeds the 240 KB task limit. Use a bounded task file instead.');
   const labels = issueLabels(issue.labels);
-  return { title: issue.title, url, number: canonicalIssue(url).number, state: issue.state?.toLowerCase() || 'unknown', body: issue.body, spec, labels, recommendation: recommendWork({ spec, labels: labels.map(label => label.name) }) };
+  return { ...issueMetadata(issue), title: issue.title, url, number: canonicalIssue(url).number, state: issue.state?.toLowerCase() || 'unknown', body: issue.body, spec, labels, recommendation: recommendWork({ spec, labels: labels.map(label => label.name) }) };
 }

package/factory/issue-lifecycle.mjs

@@ -57,3 +57,28 @@ export function backlogHistory(jobs, issues) {
   }
   return [...grouped.values()];
 }
+
+// Canonical all-work read model, shared by headless readers and the dashboard.
+// A source page is a bounded snapshot, never evidence that other sources closed.
+export function workRecords(jobs = [], issues = []) {
+  const sources = new Map(issues.map(issue => [issue.identity.key, issue]));
+  const histories = backlogHistory(jobs, []);
+  const rows = new Map(histories.map(row => [row.key, row]));
+  for (const [key, issue] of sources) rows.set(key, {
+    ...issue, key, ...executionAssociation(jobs, issue.identity),
+  });
+  return [...rows.values()].map(row => {
+    const issue = sources.get(row.key) || null;
+    const execution = row.active_execution || row.latest_execution || row.executions[0] || null;
+    return {
+      key: row.key, identity: row.identity, title: issue?.title || row.title,
+      url: row.url, source_status: issue ? 'loaded' : row.identity ? 'not_loaded' : 'local',
+      issue, executions: row.executions, active_execution: row.active_execution || null,
+      latest_execution: row.latest_execution || execution,
+      execution_id: execution?.id || null,
+      state: execution?.state || 'not_started',
+      workflow: execution?.workflow || null,
+      phase: execution?.phase || null,
+    };
+  });
+}

package/factory/lib.mjs

@@ -19,7 +19,7 @@ export function run(command, args, options = {}) {
   const result = spawnSync(command, args, { encoding: 'utf8', maxBuffer: 32 * 1024 * 1024, ...options });
   if (result.error) throw result.error;
   if (result.status !== 0) throw new Error(`${command} failed (${result.status}): ${result.stderr || result.stdout || ''}`);
-  return result.stdout?.trim() ?? '';
+  return Buffer.isBuffer(result.stdout) ? result.stdout : result.stdout?.trim() ?? '';
 }
 export function stream(command, args, options = {}) {
   return new Promise((ok, fail) => {

package/factory/providers/github.mjs

@@ -38,7 +38,7 @@ export function githubIssueProvider(repo, { read = githubRead, write = githubWri
     id: 'github', label: 'GitHub', repository, supported: true,
     capabilities: { issues: true, templates: true, create: true },
     list: (page, state) => listIssues(repo, page, read, state),
-    preview: url => readIssue(repo, url, value => read(['issue', 'view', value, '--json', 'title,body,url,labels,state'])),
+    preview: url => readIssue(repo, url, value => read(['issue', 'view', value, '--json', 'title,body,url,labels,state,author,createdAt,updatedAt'])),
     templates: () => readTemplates(repo, read),
     draft: input => draftFromTemplate(repo, input, read),
     async context() {

package/factory/server.mjs

@@ -1,4 +1,4 @@
-import { associateIssue, backlogHistory, readinessMapping } from './issue-lifecycle.mjs';
+import { associateIssue, backlogHistory, readinessMapping, workRecords } from './issue-lifecycle.mjs';
 import { harnessOf } from './lib.mjs';
 import http from 'node:http';
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
@@ -88,7 +88,7 @@ export function createController(state, adapter = executors(state), integrations
           delivery_removal_blocked: Boolean(job.delivery && !['published', 'abandoned'].includes(job.delivery.state)),
           delivery_status: delivery.summary(job), runs: job.runs.map(attempt => attemptPresentation({ ...attempt,
           outcome: attempt.outcome || (attempt.state === 'succeeded' ? 'complete' : undefined) }, adapter.usage?.(job, attempt))) }));
-        return send(200, { version: 1, runtime_version: VERSION, maintenance: queue.maintenance, workflows: Object.keys(definitions.workflows), commands: [], triggers: [], jobs, issue_history: backlogHistory(jobs, []), csrf_token: csrf,
+        return send(200, { version: 1, runtime_version: VERSION, maintenance: queue.maintenance, workflows: Object.keys(definitions.workflows), commands: [], triggers: [], jobs, issue_history: backlogHistory(jobs, []), work_records: workRecords(jobs, []), csrf_token: csrf,
           infrastructure: { host, controller: { connected: !queue.closing }, workers: [{ id: 'local-executor', name: 'Local worker', host: host.hostname, connected: !queue.closing }] },
           automations: [], automation_control: definitions.automations, issue_provider: providerInfo(provider),
           delivery_configuration: deliveryProviderInfo(configAt(state), deliveryAdapter),
@@ -106,7 +106,7 @@ export function createController(state, adapter = executors(state), integrations
           const result = provider.supported ? await provider.list(page, state) : {repository:provider.repository, issues:[],next_page:null};
           const jobs = queue.all(), issues = result.issues.map(issue => associateIssue(issue, jobs, readinessMapping(config.issueReadinessLabels)));
           return send(200, { ...result, issues, provider:providerInfo(provider), page, state, loaded_count:issues.length, total:null,
-            history:backlogHistory(jobs, issues) });
+            history:backlogHistory(jobs, issues), work_records:workRecords(jobs, issues) });
         }
         catch (error) { throw new QueueError(error.message, error.status || 400); }
       }