@thxgg/steward 0.1.24 → 0.1.26

package/.output/server/node_modules/diff/package.json

@@ -0,0 +1,132 @@
+{
+  "name": "diff",
+  "version": "8.0.3",
+  "description": "A JavaScript text diff implementation.",
+  "keywords": [
+    "diff",
+    "jsdiff",
+    "compare",
+    "patch",
+    "text",
+    "json",
+    "css",
+    "javascript"
+  ],
+  "maintainers": [
+    "Kevin Decker <kpdecker@gmail.com> (http://incaseofstairs.com)",
+    "Mark Amery <markrobertamery+jsdiff@gmail.com>"
+  ],
+  "bugs": {
+    "email": "kpdecker@gmail.com",
+    "url": "http://github.com/kpdecker/jsdiff/issues"
+  },
+  "license": "BSD-3-Clause",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kpdecker/jsdiff.git"
+  },
+  "engines": {
+    "node": ">=0.3.1"
+  },
+  "main": "./libcjs/index.js",
+  "module": "./libesm/index.js",
+  "browser": "./dist/diff.js",
+  "unpkg": "./dist/diff.js",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./libesm/index.d.ts",
+        "default": "./libesm/index.js"
+      },
+      "require": {
+        "types": "./libcjs/index.d.ts",
+        "default": "./libcjs/index.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./lib/*.js": {
+      "import": {
+        "types": "./libesm/*.d.ts",
+        "default": "./libesm/*.js"
+      },
+      "require": {
+        "types": "./libcjs/*.d.ts",
+        "default": "./libcjs/*.js"
+      }
+    },
+    "./lib/": {
+      "import": {
+        "types": "./libesm/",
+        "default": "./libesm/"
+      },
+      "require": {
+        "types": "./libcjs/",
+        "default": "./libcjs/"
+      }
+    }
+  },
+  "type": "module",
+  "types": "libcjs/index.d.ts",
+  "scripts": {
+    "clean": "rm -rf libcjs/ libesm/ dist/ coverage/ .nyc_output/",
+    "lint": "yarn eslint",
+    "build": "yarn lint && yarn generate-esm && yarn generate-cjs && yarn check-types && yarn run-rollup && yarn run-uglify",
+    "generate-cjs": "yarn tsc --module commonjs --outDir libcjs && node --eval \"fs.writeFileSync('libcjs/package.json', JSON.stringify({type:'commonjs',sideEffects:false}))\"",
+    "generate-esm": "yarn tsc --module nodenext --outDir libesm --target es6 && node --eval \"fs.writeFileSync('libesm/package.json', JSON.stringify({type:'module',sideEffects:false}))\"",
+    "check-types": "yarn run-tsd && yarn run-attw",
+    "test": "nyc yarn _test",
+    "_test": "yarn build && cross-env NODE_ENV=test yarn run-mocha",
+    "run-attw": "yarn attw --pack --entrypoints . && yarn attw --pack --entrypoints lib/diff/word.js --profile node16",
+    "run-tsd": "yarn tsd --typings libesm/ && yarn tsd --files test-d/",
+    "run-rollup": "rollup -c rollup.config.mjs",
+    "run-uglify": "uglifyjs dist/diff.js -c -o dist/diff.min.js",
+    "run-mocha": "mocha --require ./runtime 'test/**/*.js'"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.4",
+    "@babel/core": "^7.26.9",
+    "@babel/preset-env": "^7.26.9",
+    "@babel/register": "^7.25.9",
+    "@colors/colors": "^1.6.0",
+    "@eslint/js": "^9.25.1",
+    "babel-loader": "^10.0.0",
+    "babel-plugin-istanbul": "^7.0.0",
+    "chai": "^5.2.0",
+    "cross-env": "^7.0.3",
+    "eslint": "^9.25.1",
+    "globals": "^16.0.0",
+    "karma": "^6.4.4",
+    "karma-mocha": "^2.0.1",
+    "karma-mocha-reporter": "^2.2.5",
+    "karma-sourcemap-loader": "^0.4.0",
+    "karma-webpack": "^5.0.1",
+    "mocha": "^11.1.0",
+    "nyc": "^17.1.0",
+    "rollup": "^4.40.1",
+    "tsd": "^0.32.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.31.0",
+    "uglify-js": "^3.19.3",
+    "webpack": "^5.99.7",
+    "webpack-dev-server": "^5.2.1"
+  },
+  "optionalDependencies": {},
+  "dependencies": {},
+  "nyc": {
+    "require": [
+      "@babel/register"
+    ],
+    "reporter": [
+      "lcov",
+      "text"
+    ],
+    "sourceMap": false,
+    "instrument": false,
+    "check-coverage": true,
+    "branches": 100,
+    "lines": 100,
+    "functions": 100,
+    "statements": 100
+  },
+  "packageManager": "yarn@1.22.22+sha1.ac34549e6aa8e7ead463a7407e1c7390f61a6610"
+}

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.24",
+  "version": "0.1.26",
   "type": "module",
   "private": true,
   "dependencies": {
@@ -11,11 +11,13 @@
     "@floating-ui/vue": "1.1.10",
     "@internationalized/date": "3.11.0",
     "@internationalized/number": "3.6.5",
+    "@pierre/diffs": "1.0.11",
     "@shikijs/core": "3.22.0",
     "@shikijs/engine-javascript": "3.22.0",
     "@shikijs/engine-oniguruma": "3.22.0",
     "@shikijs/langs": "3.22.0",
     "@shikijs/themes": "3.22.0",
+    "@shikijs/transformers": "3.23.0",
     "@shikijs/types": "3.22.0",
     "@shikijs/vscode-textmate": "10.0.2",
     "@swc/helpers": "0.5.18",
@@ -45,6 +47,7 @@
     "comma-separated-tokens": "2.0.3",
     "defu": "6.1.4",
     "devalue": "5.6.3",
+    "diff": "8.0.3",
     "dompurify": "3.3.1",
     "entities": "7.0.1",
     "estree-walker": "2.0.2",

package/README.md

@@ -58,14 +58,55 @@ Note: `execute` runs in a VM sandbox by design, so globals like `process` are in
 prd ui
 prd ui --port 3100 --host 127.0.0.1
 prd mcp
+prd sync export ./steward-sync.json
+prd sync inspect ./steward-sync.json
+prd sync merge ./steward-sync.json
+prd sync merge ./steward-sync.json --apply
+prd sync merge ./steward-sync.json --apply --map rsk_source=/Users/you/Projects/repo
 ```
 
+### Sync Bundles (Cross-Device)
+
+Steward supports local-first state sharing across devices using portable JSON bundles.
+
+- `prd sync export <bundle-path>` writes a versioned bundle of repos/state/archives.
+- `prd sync inspect <bundle-path>` validates and summarizes bundle contents.
+- `prd sync merge <bundle-path>` plans a merge in dry-run mode by default.
+- `prd sync merge <bundle-path> --apply` applies the planned merge transactionally.
+
+Path hint privacy defaults:
+
+- Export defaults to `--path-hints basename` to avoid leaking absolute filesystem paths.
+- Use `--path-hints none` to omit path hints entirely.
+- Use `--path-hints absolute` only when you explicitly want full paths in the bundle.
+
+Representative command output summaries:
+
+- `sync export` prints bundle path, bundle id, and row totals (`repos/states/archives`).
+- `sync inspect` prints bundle metadata (`bundleId`, `sourceDeviceId`, format version), totals, and unknown references.
+- `sync merge` prints mapping totals, state/archive action counts, and conflict counts.
+- `sync merge --apply` also prints backup path and retention cleanup counts.
+
+Safety defaults and retention:
+
+- Merge defaults to dry-run; no writes happen unless `--apply` is provided.
+- Apply creates a SQLite backup before any write and runs an integrity check before commit.
+- Re-applying the same bundle id is idempotent and returns a no-op result.
+- Default retention keeps backups for 30 days (max 20 files) and sync apply logs for 180 days (max 10,000 rows).
+
+Troubleshooting sync:
+
+- Unresolved mapping on apply: run `prd sync inspect <bundle-path>` and pass one or more `--map <incomingRepoSyncKey>=<localPathOrRepoRef>` values.
+- Expected no-op reapply: if bundle id was already applied, merge returns "already applied" and leaves state unchanged.
+- Restore from backup: stop Steward processes, then replace your DB file with a backup in the same directory (files match `state.db.sync-backup.*.db`).
+
 ## Architecture
 
 ```
 ┌─────────────────────────────────────────┐
 │            Steward CLI (Node)           │
 │  - `prd ui` runs prebuilt UI server     │
+│  - `prd sync` manages state bundles     │
 │  - `prd mcp` starts MCP over stdio      │
 └─────────────────────────────────────────┘
                     │

package/bin/prd

@@ -12,7 +12,7 @@ const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const entryPath = resolve(packageRoot, 'dist', 'host', 'src', 'index.js')
 
 function requiresSqliteRuntime(command) {
-  return command === 'mcp' || command === 'ui'
+  return command === 'mcp' || command === 'ui' || command === 'sync'
 }
 
 function isSqliteRuntimeError(error) {

package/dist/host/src/index.js

@@ -1,14 +1,17 @@
 import { runMcpServer } from './mcp.js';
+import { runSync } from './sync.js';
 import { runUi } from './ui.js';
 function printUsage() {
     console.log(`prd - Steward CLI
 
 Usage:
   prd ui [--preview] [--port <port>] [--host <host>]
+  prd sync <subcommand> [options]
   prd mcp
 
 Commands:
   ui         Launch the prebuilt PRD web UI server
+  sync       Export/inspect/merge sync bundles
   mcp        Start MCP server over stdio (codemode)
 
 Options:
@@ -84,6 +87,13 @@ export async function main(argv = process.argv.slice(2)) {
         }
         return;
     }
+    if (command === 'sync') {
+        const exitCode = await runSync(rest);
+        if (exitCode !== 0) {
+            process.exitCode = exitCode;
+        }
+        return;
+    }
     throw new Error(`Unknown command: ${command}`);
 }
 if (import.meta.main) {

package/dist/host/src/sync.js

@@ -0,0 +1,201 @@
+import { promises as fs } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { buildSyncBundle, serializeSyncBundle } from '../../server/utils/sync-export.js';
+import { executeSyncMergeJson } from '../../server/utils/sync-apply.js';
+import { inspectSyncBundleJson } from '../../server/utils/sync-inspect.js';
+function printSyncUsage() {
+    console.log(`Sync Usage:
+  prd sync export <bundle-path> [--path-hints basename|none|absolute]
+  prd sync inspect <bundle-path>
+  prd sync merge <bundle-path> [--map <incomingRepoSyncKey>=<localPathOrRepoRef>] [--dry-run] [--apply]
+
+Notes:
+  - merge defaults to --dry-run when --apply is omitted
+  - --map can be provided multiple times
+`);
+}
+function resolveBundlePath(pathInput) {
+    return resolve(process.cwd(), pathInput);
+}
+function parsePathHintsMode(rawValue) {
+    if (rawValue === 'basename' || rawValue === 'none' || rawValue === 'absolute') {
+        return rawValue;
+    }
+    throw new Error(`Invalid --path-hints value: ${rawValue}`);
+}
+function parseMapAssignment(rawValue) {
+    const separatorIndex = rawValue.indexOf('=');
+    if (separatorIndex <= 0 || separatorIndex >= rawValue.length - 1) {
+        throw new Error(`Invalid --map value: ${rawValue}. Expected <incomingRepoSyncKey>=<localPathOrRepoRef>`);
+    }
+    const source = rawValue.slice(0, separatorIndex).trim();
+    const target = rawValue.slice(separatorIndex + 1).trim();
+    if (!source || !target) {
+        throw new Error(`Invalid --map value: ${rawValue}. Expected <incomingRepoSyncKey>=<localPathOrRepoRef>`);
+    }
+    return { source, target };
+}
+export function parseSyncExportArgs(args) {
+    let bundlePath = null;
+    let pathHints = 'basename';
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === '--path-hints') {
+            const next = args[index + 1];
+            if (!next) {
+                throw new Error('--path-hints requires a value');
+            }
+            pathHints = parsePathHintsMode(next);
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown option for sync export: ${arg}`);
+        }
+        if (bundlePath !== null) {
+            throw new Error(`Unexpected argument for sync export: ${arg}`);
+        }
+        bundlePath = arg;
+    }
+    if (!bundlePath) {
+        throw new Error('sync export requires <bundle-path>');
+    }
+    return {
+        bundlePath: resolveBundlePath(bundlePath),
+        pathHints
+    };
+}
+export function parseSyncInspectArgs(args) {
+    const [bundlePath] = args;
+    if (args.length !== 1 || !bundlePath || bundlePath.startsWith('--')) {
+        throw new Error('sync inspect requires exactly one <bundle-path>');
+    }
+    return {
+        bundlePath: resolveBundlePath(bundlePath)
+    };
+}
+export function parseSyncMergeArgs(args) {
+    let bundlePath = null;
+    let apply = false;
+    let dryRun = false;
+    const repoMap = {};
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === '--apply') {
+            apply = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (arg === '--map') {
+            const next = args[index + 1];
+            if (!next) {
+                throw new Error('--map requires a value');
+            }
+            const { source, target } = parseMapAssignment(next);
+            repoMap[source] = target;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--')) {
+            throw new Error(`Unknown option for sync merge: ${arg}`);
+        }
+        if (bundlePath !== null) {
+            throw new Error(`Unexpected argument for sync merge: ${arg}`);
+        }
+        bundlePath = arg;
+    }
+    if (!bundlePath) {
+        throw new Error('sync merge requires <bundle-path>');
+    }
+    if (apply && dryRun) {
+        throw new Error('Cannot use --apply and --dry-run together');
+    }
+    return {
+        bundlePath: resolveBundlePath(bundlePath),
+        apply,
+        repoMap
+    };
+}
+async function runSyncExport(args) {
+    const parsed = parseSyncExportArgs(args);
+    const bundle = await buildSyncBundle({
+        pathHints: parsed.pathHints
+    });
+    await fs.mkdir(dirname(parsed.bundlePath), { recursive: true });
+    await fs.writeFile(parsed.bundlePath, `${serializeSyncBundle(bundle)}\n`, 'utf-8');
+    console.log(`[steward] Exported bundle: ${parsed.bundlePath}`);
+    console.log(`[steward] Bundle ID: ${bundle.bundleId}`);
+    console.log(`[steward] Rows: repos=${bundle.repos.length} states=${bundle.states.length} archives=${bundle.archives.length}`);
+    return 0;
+}
+async function runSyncInspect(args) {
+    const parsed = parseSyncInspectArgs(args);
+    const jsonPayload = await fs.readFile(parsed.bundlePath, 'utf-8');
+    const inspection = inspectSyncBundleJson(jsonPayload);
+    console.log(`[steward] Bundle: ${parsed.bundlePath}`);
+    console.log(`[steward] ID=${inspection.bundleId} sourceDevice=${inspection.sourceDeviceId} format=v${inspection.formatVersion}`);
+    console.log(`[steward] Totals: repos=${inspection.totals.repos} states=${inspection.totals.states} archives=${inspection.totals.archives}`);
+    console.log(`[steward] Unknown references: states=${inspection.totals.unknownRepoStates} archives=${inspection.totals.unknownRepoArchives}`);
+    for (const repo of inspection.repos) {
+        const hint = repo.pathHint ? ` pathHint=${repo.pathHint}` : '';
+        console.log(`[steward] Repo ${repo.repoSyncKey} (${repo.name})${hint} states=${repo.stateCount} archives=${repo.archiveCount}`);
+    }
+    return 0;
+}
+async function runSyncMerge(args) {
+    const parsed = parseSyncMergeArgs(args);
+    const jsonPayload = await fs.readFile(parsed.bundlePath, 'utf-8');
+    const result = await executeSyncMergeJson(jsonPayload, {
+        apply: parsed.apply,
+        repoMap: parsed.repoMap
+    });
+    const mode = result.mode === 'dry_run' ? 'dry-run' : 'apply';
+    console.log(`[steward] Merge mode: ${mode}`);
+    console.log(`[steward] Bundle ID: ${result.bundleId}`);
+    console.log(`[steward] Repo mapping: mapped=${result.plan.summary.repos.mapped} unresolved=${result.plan.summary.repos.unresolved}`);
+    console.log(`[steward] State actions: insert=${result.plan.summary.states.insert} update=${result.plan.summary.states.update} skip=${result.plan.summary.states.skip} unresolved=${result.plan.summary.states.unresolved} conflicts=${result.plan.summary.states.conflicts}`);
+    console.log(`[steward] Archive actions: insert=${result.plan.summary.archives.insert} update=${result.plan.summary.archives.update} skip=${result.plan.summary.archives.skip} unresolved=${result.plan.summary.archives.unresolved}`);
+    if (result.mode === 'apply') {
+        if (result.alreadyApplied) {
+            console.log('[steward] Bundle already applied; no changes were written.');
+        }
+        else {
+            console.log(`[steward] Applied: ${result.applied ? 'yes' : 'no'}`);
+            if (result.backupPath) {
+                console.log(`[steward] Backup: ${result.backupPath}`);
+            }
+            console.log(`[steward] Retention: backupsDeleted=${result.retention.backupsDeleted} logsDeleted=${result.retention.logsDeleted}`);
+        }
+    }
+    else {
+        console.log('[steward] Dry-run only; re-run with --apply to write changes.');
+    }
+    return 0;
+}
+export async function runSync(args) {
+    const [subcommandRaw, ...rest] = args;
+    const subcommand = subcommandRaw || '';
+    if (subcommand === '' || subcommand === '-h' || subcommand === '--help') {
+        printSyncUsage();
+        return 0;
+    }
+    if (subcommand === 'export') {
+        return await runSyncExport(rest);
+    }
+    if (subcommand === 'inspect') {
+        return await runSyncInspect(rest);
+    }
+    if (subcommand === 'merge') {
+        return await runSyncMerge(rest);
+    }
+    throw new Error(`Unknown sync subcommand: ${subcommandRaw}`);
+}

package/dist/server/utils/db.js

@@ -34,6 +34,47 @@ function resolveDbPath() {
     }
     return DEFAULT_DB_PATH;
 }
+function getTableColumnNames(adapter, tableName) {
+    const rows = adapter.all(`PRAGMA table_info(${tableName})`);
+    const names = new Set();
+    for (const row of rows) {
+        if (typeof row.name === 'string' && row.name.length > 0) {
+            names.add(row.name);
+        }
+    }
+    return names;
+}
+function ensurePrdStateFieldClockColumns(adapter) {
+    const columnNames = getTableColumnNames(adapter, 'prd_states');
+    const requiredColumns = ['tasks_updated_at', 'progress_updated_at', 'notes_updated_at'];
+    for (const columnName of requiredColumns) {
+        if (columnNames.has(columnName)) {
+            continue;
+        }
+        adapter.exec(`ALTER TABLE prd_states ADD COLUMN ${columnName} TEXT;`);
+        columnNames.add(columnName);
+    }
+}
+function backfillPrdStateFieldClocks(adapter) {
+    adapter.run(`
+      UPDATE prd_states
+      SET tasks_updated_at = updated_at
+      WHERE tasks_updated_at IS NULL
+        AND tasks_json IS NOT NULL
+    `);
+    adapter.run(`
+      UPDATE prd_states
+      SET progress_updated_at = updated_at
+      WHERE progress_updated_at IS NULL
+        AND progress_json IS NOT NULL
+    `);
+    adapter.run(`
+      UPDATE prd_states
+      SET notes_updated_at = updated_at
+      WHERE notes_updated_at IS NULL
+        AND notes_md IS NOT NULL
+    `);
+}
 function formatNodeRuntimeHint() {
     const nodeOptions = process.env.NODE_OPTIONS || '';
     const hasDisableFlag = process.execArgv.includes(SQLITE_DISABLE_FLAG)
@@ -177,6 +218,9 @@ async function initializeDatabase() {
       tasks_json TEXT,
       progress_json TEXT,
       notes_md TEXT,
+      tasks_updated_at TEXT,
+      progress_updated_at TEXT,
+      notes_updated_at TEXT,
       updated_at TEXT NOT NULL,
       PRIMARY KEY (repo_id, slug),
       FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
@@ -196,9 +240,29 @@ async function initializeDatabase() {
       updated_at TEXT NOT NULL
     );
 
+    CREATE TABLE IF NOT EXISTS repo_sync_meta (
+      repo_id TEXT PRIMARY KEY,
+      sync_key TEXT NOT NULL UNIQUE,
+      fingerprint TEXT,
+      fingerprint_kind TEXT,
+      updated_at TEXT NOT NULL,
+      FOREIGN KEY (repo_id) REFERENCES repos(id) ON DELETE CASCADE
+    );
+
+    CREATE TABLE IF NOT EXISTS sync_bundle_log (
+      bundle_id TEXT PRIMARY KEY,
+      source_device_id TEXT,
+      applied_at TEXT NOT NULL,
+      summary_json TEXT NOT NULL
+    );
+
     CREATE INDEX IF NOT EXISTS idx_prd_states_repo_id ON prd_states(repo_id);
     CREATE INDEX IF NOT EXISTS idx_prd_archives_repo_id ON prd_archives(repo_id);
+    CREATE INDEX IF NOT EXISTS idx_repo_sync_meta_sync_key ON repo_sync_meta(sync_key);
+    CREATE INDEX IF NOT EXISTS idx_sync_bundle_log_applied_at ON sync_bundle_log(applied_at);
   `);
+    ensurePrdStateFieldClockColumns(adapter);
+    backfillPrdStateFieldClocks(adapter);
     return adapter;
 }
 async function getAdapter() {

package/dist/server/utils/git.js

@@ -168,12 +168,13 @@ export async function getCommitInfo(repoPath, sha) {
         throw new Error(`Invalid commit SHA: ${sha}`);
     }
     // Get commit details
-    const format = '%H%n%h%n%s%n%an%n%aI';
+    const format = '%H%n%P%n%h%n%s%n%an%n%aI';
     const output = await execGit(repoPath, ['show', sha, '--format=' + format, '--no-patch']);
     const lines = output.trim().split('\n');
-    if (lines.length < 5) {
+    if (lines.length < 6) {
         throw new Error(`Failed to parse commit info for ${sha}`);
     }
+    const parentSha = lines[1]?.trim().split(' ').filter(Boolean)[0];
     // Get stats
     const statsOutput = await execGit(repoPath, ['show', sha, '--format=', '--numstat']);
     const statsLines = statsOutput.trim().split('\n').filter(l => l.trim());
@@ -192,10 +193,11 @@ export async function getCommitInfo(repoPath, sha) {
     }
     return {
         sha: lines[0],
-        shortSha: lines[1],
-        message: lines[2],
-        author: lines[3],
-        date: lines[4],
+        parentSha: parentSha || undefined,
+        shortSha: lines[2],
+        message: lines[3],
+        author: lines[4],
+        date: lines[5],
         filesChanged,
         additions,
         deletions,

package/dist/server/utils/prd-state.js

@@ -92,13 +92,29 @@ export async function upsertPrdState(repoId, slug, update) {
         ? null
         : update.notes;
     const updatedAt = new Date().toISOString();
+    const tasksUpdatedAt = updateTasks ? updatedAt : null;
+    const progressUpdatedAt = updateProgress ? updatedAt : null;
+    const notesUpdatedAt = updateNotes ? updatedAt : null;
     await dbRun(`
-      INSERT INTO prd_states (repo_id, slug, tasks_json, progress_json, notes_md, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
+      INSERT INTO prd_states (
+        repo_id,
+        slug,
+        tasks_json,
+        progress_json,
+        notes_md,
+        tasks_updated_at,
+        progress_updated_at,
+        notes_updated_at,
+        updated_at
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
       ON CONFLICT(repo_id, slug) DO UPDATE SET
         tasks_json = CASE WHEN ? THEN excluded.tasks_json ELSE prd_states.tasks_json END,
         progress_json = CASE WHEN ? THEN excluded.progress_json ELSE prd_states.progress_json END,
         notes_md = CASE WHEN ? THEN excluded.notes_md ELSE prd_states.notes_md END,
+        tasks_updated_at = CASE WHEN ? THEN excluded.tasks_updated_at ELSE prd_states.tasks_updated_at END,
+        progress_updated_at = CASE WHEN ? THEN excluded.progress_updated_at ELSE prd_states.progress_updated_at END,
+        notes_updated_at = CASE WHEN ? THEN excluded.notes_updated_at ELSE prd_states.notes_updated_at END,
         updated_at = excluded.updated_at
     `, [
         repoId,
@@ -106,9 +122,15 @@ export async function upsertPrdState(repoId, slug, update) {
         tasksJson,
         progressJson,
         notesMd,
+        tasksUpdatedAt,
+        progressUpdatedAt,
+        notesUpdatedAt,
         updatedAt,
         updateTasks ? 1 : 0,
         updateProgress ? 1 : 0,
+        updateNotes ? 1 : 0,
+        updateTasks ? 1 : 0,
+        updateProgress ? 1 : 0,
         updateNotes ? 1 : 0
     ]);
     if (validatedTasks !== undefined) {

package/dist/server/utils/repos.js

@@ -3,6 +3,7 @@ import { join, basename, dirname, resolve, relative, isAbsolute } from 'node:pat
 import { randomUUID } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { dbAll, dbGet, dbRun } from './db.js';
+import { ensureRepoSyncMetaForRepo, ensureRepoSyncMetaForRepos } from './sync-identity.js';
 function findPackageRoot(startDir) {
     let currentDir = startDir;
     while (true) {
@@ -136,7 +137,9 @@ async function importLegacyReposIfNeeded() {
 export async function getRepos() {
     await importLegacyReposIfNeeded();
     const rows = await dbAll('SELECT id, name, path, added_at, git_repos_json FROM repos ORDER BY added_at ASC');
-    return rows.map(rowToRepo);
+    const repos = rows.map(rowToRepo);
+    await ensureRepoSyncMetaForRepos(repos);
+    return repos;
 }
 export async function saveRepos(repos) {
     await importLegacyReposIfNeeded();
@@ -158,6 +161,7 @@ export async function saveRepos(repos) {
     const repoIds = repos.map(repo => repo.id);
     const placeholders = repoIds.map(() => '?').join(', ');
     await dbRun(`DELETE FROM repos WHERE id NOT IN (${placeholders})`, repoIds);
+    await ensureRepoSyncMetaForRepos(repos);
 }
 export async function addRepo(path, name) {
     await importLegacyReposIfNeeded();
@@ -175,6 +179,7 @@ export async function addRepo(path, name) {
         ...(gitRepos.length > 0 && { gitRepos })
     };
     await dbRun('INSERT INTO repos (id, name, path, added_at, git_repos_json) VALUES (?, ?, ?, ?, ?)', [repo.id, repo.name, repo.path, repo.addedAt, serializeGitRepos(repo.gitRepos)]);
+    await ensureRepoSyncMetaForRepo(repo);
     return repo;
 }
 /**
@@ -183,7 +188,12 @@ export async function addRepo(path, name) {
 export async function getRepoById(id) {
     await importLegacyReposIfNeeded();
     const row = await dbGet('SELECT id, name, path, added_at, git_repos_json FROM repos WHERE id = ?', [id]);
-    return row ? rowToRepo(row) : undefined;
+    if (!row) {
+        return undefined;
+    }
+    const repo = rowToRepo(row);
+    await ensureRepoSyncMetaForRepo(repo);
+    return repo;
 }
 export async function updateRepoGitRepos(id, gitRepos) {
     await importLegacyReposIfNeeded();