@ulysses-ai/create-workspace 0.23.0-beta.0 → 0.23.2-beta.0

package/template/_claude/scripts/classify-update.mjs

@@ -67,11 +67,25 @@
 //                (machine-local), paths under .claude/worktrees/, and entries
 //                of workspace.json → workspace.localFiles (array of
 //                .claude/-relative paths or globs for files this workspace
-//                owns) (gh:180)
+//                owns) (gh:180). Two markers refine the per-file offer
+//                (gh:190): `{ file, referencedBy }` — a removed hook that a
+//                workspace-only settings.json entry still registers (the
+//                config-diff paths); the skill removes file and settings
+//                entry together. `{ file, userOwned: true }` — no baseline
+//                entry, so the template never shipped it: the workspace's
+//                own, offered a workspace.localFiles entry, not deletion.
 //   staleTests — *.test.mjs files under .claude/ with no payload counterpart.
 //                The npm tarball ships no tests, so these came from a dev
 //                checkout and are never updated by /workspace-update; the
 //                skill offers to remove them (tests live in the template repo)
+//   implicitDefaults — workspace.json keys whose ABSENCE carried a default
+//                in the version being upgraded FROM but not in the payload's:
+//                canonicalBudgetBytes meant a 40960-byte budget when absent
+//                from v0.15.0-beta.1 until v0.19.0-beta.0 made it opt-in
+//                (absent since means off; before v0.15 there was no budget).
+//                An upgrade from inside that window into a workspace.json
+//                without the key reports { key, value, reason } so the skill
+//                writes the value explicitly (gh:190).
 //
 // Plus `hasBaseline`: whether a usable baseline was found, `baselineSource`
 // (which file it came from) and `baselineReconstructed`. The default
@@ -103,10 +117,15 @@
 //                     present as `updated` again next time; see
 //                     template-baseline.mjs. Throws rather than writing an
 //                     empty baseline.
-//   --merge-claude-md print CLAUDE.md with the payload's CLAUDE.md.tmpl
-//                     merged in: template lines updated, the workspace's own
-//                     lines (custom skill entries, sections) kept. The skill
-//                     shows the diff against the current file before writing.
+//   --merge-claude-md print JSON { claudeMd, missingIncludes }: CLAUDE.md
+//                     with the payload's CLAUDE.md.tmpl merged in — template
+//                     lines updated, the workspace's own lines (custom skill
+//                     entries, sections) kept — plus the `@{path}` include
+//                     lines the merged file carries whose targets don't
+//                     exist at the root (machine-local local-only-* targets
+//                     exempt). The skill shows the diff against the current
+//                     file before writing, and asks on each missing include
+//                     instead of leaving it dangling (gh:190).
 
 import {
   existsSync,
@@ -118,6 +137,7 @@ import {
 import { basename, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { gitIgnoredPaths } from './build-workspace-context.mjs';
+import { compareVersions } from '../lib/registry-check.mjs';
 import {
   BASELINE_PATH,
   RECONSTRUCTED_BASELINE_NAME,
@@ -354,6 +374,47 @@ export function resolveBaseline({ root, payload, baseline = null }) {
   return { baseline: null, source: null };
 }
 
+/**
+ * workspace.json keys whose absence carried a default in the version being
+ * upgraded FROM but not in the payload's. The canonical budget existed as an
+ * implicit default only between v0.15.0-beta.1 (gh:97, which introduced it:
+ * absent meant a 40960-byte budget) and v0.19.0-beta.0 (gh:164, which made
+ * it opt-in: absent means off since). Before v0.15 there was no budget at
+ * all, so a workspace upgrading from there also has none to preserve —
+ * reporting the key would turn trimming ON. Only an upgrade from inside
+ * that window into a workspace.json that never wrote the key reports it,
+ * and the skill writes the explicit value and says so (gh:190).
+ */
+const CANONICAL_BUDGET_INTRODUCED = '0.15.0-beta.1';
+const CANONICAL_BUDGET_OPT_IN = '0.19.0-beta.0';
+const CANONICAL_BUDGET_DEFAULT = 40960;
+
+function implicitDefaults(absRoot, absPayload) {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(join(absPayload, '.manifest.json'), 'utf8'));
+  } catch {
+    return []; // no manifest — the payload path is wrong; nothing to infer
+  }
+  const { fromVersion } = manifest;
+  if (typeof fromVersion !== 'string' || fromVersion === 'unknown') return [];
+  if (compareVersions(fromVersion, CANONICAL_BUDGET_INTRODUCED) < 0) return [];
+  if (compareVersions(fromVersion, CANONICAL_BUDGET_OPT_IN) >= 0) return [];
+  let config;
+  try {
+    config = JSON.parse(readFileSync(join(absRoot, 'workspace.json'), 'utf8'));
+  } catch {
+    return []; // no workspace.json to preserve a default in
+  }
+  const ws = config?.workspace && typeof config.workspace === 'object' ? config.workspace : null;
+  if (!ws || Object.prototype.hasOwnProperty.call(ws, 'canonicalBudgetBytes')) return [];
+  return [{
+    key: 'canonicalBudgetBytes',
+    value: CANONICAL_BUDGET_DEFAULT,
+    reason: `absent meant a ${CANONICAL_BUDGET_DEFAULT}-byte canonical budget before v0.19 and means off since — write the value explicitly or trimming silently stops`,
+  }];
+}
+
 export function classifyUpdate({ root, payload, baseline: baselineArg = null }) {
   const absRoot = resolve(root);
   const absPayload = resolve(payload ?? join(absRoot, '.workspace-update'));
@@ -376,6 +437,7 @@ export function classifyUpdate({ root, payload, baseline: baselineArg = null })
     activated: [],
     removed: [],
     staleTests: [],
+    implicitDefaults: [],
     hasBaseline: baseline !== null,
     baselineSource: source,
     baselineReconstructed: baseline !== null && baseline.reconstructed === true,
@@ -451,11 +513,71 @@ export function classifyUpdate({ root, payload, baseline: baselineArg = null })
       continue;
     }
     if (isOwnedByWorkspace(rel, localFiles)) continue;
-    result.removed.push(rel);
+    // No baseline record means the template never shipped the file here —
+    // the workspace's own, not a template removal. Marked so the skill
+    // offers a workspace.localFiles entry instead of deletion; only a real
+    // baseline can prove the negative. An activated optional rule is the
+    // exception: the baseline records its .skip twin, which proves the
+    // template shipped it, so its removal stays plain (gh:190).
+    const templateShipped = typeof baseline?.files[rel] === 'string'
+      || (rel.startsWith('.claude/rules/') && rel.endsWith('.md')
+        && typeof baseline?.files[`${rel}.skip`] === 'string');
+    if (baseline && !templateShipped) {
+      result.removed.push({ file: rel, userOwned: true });
+    } else {
+      result.removed.push(rel);
+    }
   }
+  linkRemovedHooks(result, absRoot);
+  result.implicitDefaults = implicitDefaults(absRoot, absPayload);
   return result;
 }
 
+/**
+ * A removed hook that a workspace-only settings.json entry still registers
+ * must not be deleted while its registration stays: mark the removal with
+ * `referencedBy` — the config-diff paths (`settings.json hooks.{Event}`) —
+ * so the skill removes the file and the settings entry together (gh:190).
+ * References are looked for where the config diff shows the workspace
+ * holding what the payload doesn't: `arrays[].workspaceOnly` elements and
+ * `workspaceOnly` keys (whose value is read from its settings.json).
+ */
+function linkRemovedHooks(result, absRoot) {
+  const settings = result.config.find((c) => c.path === '.claude/settings.json');
+  if (!settings || settings.notInstalled || settings.unparseable) return;
+  const removedHooks = result.removed.filter(
+    (entry) => typeof entry === 'string' && entry.startsWith('.claude/hooks/'),
+  );
+  if (removedHooks.length === 0) return;
+  let wsHooks = null;
+  try {
+    const wsSettings = JSON.parse(readFileSync(join(absRoot, '.claude', 'settings.json'), 'utf8'));
+    if (isPlainObject(wsSettings?.hooks)) wsHooks = wsSettings.hooks;
+  } catch {
+    return; // the config entry already flagged it unparseable
+  }
+  for (let i = 0; i < result.removed.length; i++) {
+    const rel = result.removed[i];
+    if (typeof rel !== 'string' || !rel.startsWith('.claude/hooks/')) continue;
+    const referencedBy = [];
+    for (const arr of settings.arrays) {
+      if (arr.path.startsWith('hooks/') && arr.workspaceOnly.some((el) => JSON.stringify(el).includes(rel))) {
+        referencedBy.push(`settings.json ${arr.path.split('/').join('.')}`);
+      }
+    }
+    for (const path of settings.workspaceOnly) {
+      if (!path.startsWith('hooks/')) continue;
+      const event = wsHooks && wsHooks[path.split('/')[1]];
+      if (event !== undefined && JSON.stringify(event).includes(rel)) {
+        referencedBy.push(`settings.json ${path.split('/').join('.')}`);
+      }
+    }
+    if (referencedBy.length > 0) {
+      result.removed[i] = { file: rel, referencedBy };
+    }
+  }
+}
+
 // ---------- CLAUDE.md merge ----------
 
 /**
@@ -606,6 +728,25 @@ function writeBaselineMode(args) {
   }, null, 2) + '\n');
 }
 
+/**
+ * `@{path}` include lines in a CLAUDE.md body whose target file does not
+ * exist at the workspace root. Machine-local targets (`local-only-*`
+ * basenames) are expected absent on machines that never wrote them — the
+ * same exemption the maintenance audit gives those imports — so they never
+ * report. The include-line shape mirrors context-footprint's resolveImports:
+ * a line whose trimmed content is exactly `@` plus a path.
+ */
+function missingIncludes(absRoot, text) {
+  const missing = [];
+  for (const rawLine of text.split(/\r?\n/)) {
+    const m = /^@(\S+)$/.exec(rawLine.trim());
+    if (!m) continue;
+    if (m[1].split('/').pop().startsWith('local-only-')) continue;
+    if (!existsSync(resolve(absRoot, m[1]))) missing.push(m[1]);
+  }
+  return missing;
+}
+
 function mergeClaudeMdMode(args) {
   const absRoot = resolve(args.root);
   const absPayload = resolvePayload(args);
@@ -623,7 +764,14 @@ function mergeClaudeMdMode(args) {
   const next = readFileSync(tmplPath, 'utf8').replace(/\{\{project-name\}\}/g, name);
   const claudeMdPath = join(absRoot, 'CLAUDE.md');
   const current = existsSync(claudeMdPath) ? readFileSync(claudeMdPath, 'utf8') : '';
-  process.stdout.write(mergeClaudeMd(current, next));
+  const claudeMd = mergeClaudeMd(current, next);
+  // The gained-@include check is deterministic, not something to eyeball in
+  // the diff: every include line whose target is absent here is reported so
+  // the skill asks (stub or omit) instead of writing it silently (gh:190).
+  process.stdout.write(JSON.stringify({
+    claudeMd,
+    missingIncludes: missingIncludes(absRoot, claudeMd),
+  }, null, 2) + '\n');
 }
 
 function main() {

package/template/_claude/scripts/forges/gitlab.mjs

@@ -123,7 +123,10 @@ export function createGitlabAdapter(config, { spawnFn = nodeSpawnSync, pollMs =
   // workspace MR and closes the issue ahead of CI ever publishing).
   // --auto-merge=false makes glab merge now or fail, and the post-merge
   // view verifies the merge actually happened — glab exiting 0 is not
-  // proof on its own.
+  // proof on its own. A project (or a whole group) may also require the
+  // merge to name the MR's current head SHA, so the pre-merge view's SHA
+  // rides along as --sha; when the view reports none the merge proceeds
+  // without it rather than failing — permissive projects still merge.
   async function prMerge({ id, strategy = 'merge', deleteBranch = false, repo }) {
     if (!id) throw new Error('prMerge: id is required');
     const { number, repo: parsedRepo } = parseMrId(id, repoFor(repo));
@@ -132,6 +135,7 @@ export function createGitlabAdapter(config, { spawnFn = nodeSpawnSync, pollMs =
       throw new MergeRejected(id, 'MR is a draft — mark it ready before merging');
     }
     const args = ['mr', 'merge', String(number), '--repo', parsedRepo, '--yes', '--auto-merge=false'];
+    if (before.headSha) args.push('--sha', before.headSha);
     switch (strategy) {
       case 'merge': break; // plain merge is glab's default
       case 'squash': args.push('--squash'); break;
@@ -183,6 +187,7 @@ export function createGitlabAdapter(config, { spawnFn = nodeSpawnSync, pollMs =
       mergeStateStatus: raw.detailed_merge_status ?? raw.merge_status ?? null,
       reviewDecision: '',
       headRefName: raw.source_branch,
+      headSha: raw.sha ?? null,
       baseRefName: raw.target_branch,
       isDraft: !!raw.draft,
       mergedAt: raw.merged_at,

package/template/_claude/scripts/maintenance-audit.mjs

@@ -25,7 +25,11 @@
 //                         of the git common dir), while the worktree's own
 //                         branch is only named in an info line and its dirty
 //                         tracked tree is skipped as info: in-flight work, not
-//                         drift (gh:183)
+//                         drift (gh:183). The launcher's
+//                         .claude/skills/workspace-update/ modification an
+//                         --upgrade leaves when its content equals the staged
+//                         payload's is the expected bootstrap, reported as
+//                         info, never a dirty-tree warning (gh:190)
 //   5. auto-files       — workspace-context catalogs current (the same
 //                         semantics as build-workspace-context.mjs --check)
 //   6. budget           — always-loaded context within
@@ -82,6 +86,7 @@ import {
   readIgnorePrefixes,
   isIgnored,
 } from './build-workspace-context.mjs';
+import { hashBytes } from './template-baseline.mjs';
 import { refreshIfStale } from '../lib/freshness.mjs';
 import { parseSessionContent } from '../lib/session-frontmatter.mjs';
 
@@ -157,7 +162,10 @@ export async function runAudit({
   // array — a structural delimiter, never a byte that could appear in the
   // values (NUL separators made git treat this file as binary).
   const seenFindings = new Set();
-  const add = (section, severity, file, message) => {
+  // opts.noFromUpdate: expected-absent findings (a machine-local import
+  // missing inside a task worktree) stay ambient info even when their file
+  // is on the --changed list — the update did not cause them (gh:190).
+  const add = (section, severity, file, message, opts = {}) => {
     const key = JSON.stringify([section, severity, file, message]);
     if (seenFindings.has(key)) return;
     seenFindings.add(key);
@@ -166,7 +174,7 @@ export async function runAudit({
       severity,
       file,
       message,
-      ...(changedSet.has(file) ? { fromUpdate: true } : {}),
+      ...(changedSet.has(file) && !opts.noFromUpdate ? { fromUpdate: true } : {}),
     });
   };
 
@@ -323,7 +331,10 @@ export async function runAudit({
       const posix = toPosix(spec);
       const base = posix.split('/').pop();
       if (base.startsWith('local-only-')) {
-        add('cross-reference', 'info', 'CLAUDE.md', `@${posix} is absent — machine-local, expected on other machines`);
+        // Machine-local files never materialize inside a task worktree (the
+        // update flow audits from one), so this is ambient, never something
+        // the update caused (gh:190).
+        add('cross-reference', 'info', 'CLAUDE.md', `@${posix} is absent — machine-local, expected on other machines`, { noFromUpdate: true });
       } else if (posix === 'CODEBASE.md') {
         add('cross-reference', 'info', 'CLAUDE.md', '@CODEBASE.md is absent — optional stub, /workspace-init generates it on request');
       } else if (isAutoFileRel(posix, wcDir)) {
@@ -379,6 +390,9 @@ export async function runAudit({
       return relToWC.split('/').includes('archive');
     };
 
+    // Resolved lifecycles are closed out, not defects — however many there
+    // are, they surface as ONE info line, not one per file (gh:190).
+    const resolvedFiles = [];
     for (let i = 0; i < files.length; i++) {
       const rel = rels[i];
       if (ignored.has(rel) || isHistorical(rel)) continue;
@@ -435,12 +449,17 @@ export async function runAudit({
         }
       }
       if (f.lifecycle === 'resolved') {
-        add('frontmatter', 'info', rel, 'lifecycle resolved — confirm /complete-work has processed it');
+        resolvedFiles.push(rel);
       }
       if ('confidence' in f && !['high', 'medium', 'low'].includes(f.confidence)) {
         add('frontmatter', 'warning', rel, `confidence '${f.confidence}' is not one of high, medium, low`);
       }
     }
+    if (resolvedFiles.length > 0) {
+      const names = resolvedFiles.slice(0, 3).map((rel) => rel.split('/').pop());
+      add('frontmatter', 'info', wcDir,
+        `${resolvedFiles.length} lifecycle resolved file(s) — confirm /complete-work has processed them (${names.join(', ')}${resolvedFiles.length > 3 ? ', …' : ''})`);
+    }
   })();
 
   // ---------- 4. git state ----------
@@ -463,11 +482,31 @@ export async function runAudit({
         add('git', 'warning', '.',
           `launcher is on branch '${gitInfo.launcherBranch}' — it stays on its default branch ('${gitInfo.defaultBranch}')`);
       }
+      // --upgrade replaces the launcher's workspace-update skill before the
+      // payload is applied, and the merged PR delivers the same content back:
+      // a modification that equals the staged payload's copy is the expected
+      // bootstrap, not drift — info, and out of the dirty warning (gh:190).
+      const porcelainPath = (line) => line.slice(line.indexOf(' ') + 1).split(' -> ')[0];
       const launcherDirty = gitInfo.launcherPorcelain.filter((l) => !l.startsWith('??'));
-      if (launcherDirty.length > 0) {
-        const paths = launcherDirty.slice(0, 5).map((l) => l.slice(l.indexOf(' ') + 1).replace(/ -> /, ' → '));
+      const bootstrap = launcherDirty.filter((l) => {
+        const p = porcelainPath(l);
+        if (!p.startsWith('.claude/skills/workspace-update/')) return false;
+        try {
+          return hashBytes(readFileSync(join(gitInfo.launcherRoot, p)))
+            === hashBytes(readFileSync(join(gitInfo.launcherRoot, '.workspace-update', p)));
+        } catch {
+          return false; // no staged payload copy to compare against
+        }
+      });
+      if (bootstrap.length > 0) {
+        add('git', 'info', '.',
+          "launcher's .claude/skills/workspace-update/ replaced by --upgrade (matches the staged payload) — expected until the update merges");
+      }
+      const drift = launcherDirty.filter((l) => !bootstrap.includes(l));
+      if (drift.length > 0) {
+        const paths = drift.slice(0, 5).map((l) => l.slice(l.indexOf(' ') + 1).replace(/ -> /, ' → '));
         add('git', 'warning', '.',
-          `launcher has ${launcherDirty.length} tracked file(s) with uncommitted changes: ${paths.join(', ')}${launcherDirty.length > 5 ? ', …' : ''}`);
+          `launcher has ${drift.length} tracked file(s) with uncommitted changes: ${paths.join(', ')}${drift.length > 5 ? ', …' : ''}`);
       }
       add('git', 'info', '.',
         'uncommitted-changes check skipped — the worktree is expected to carry in-flight changes');

package/template/_claude/scripts/migrate-sessions.mjs

@@ -45,7 +45,11 @@
 //                 folder is renamed into {sessions}/.archived/ and git's
 //                 worktree links are repaired to follow it. Refuses when a
 //                 worktree holds uncommitted changes (an edited session.md
-//                 counts) unless --allow-uncommitted says leave them be.
+//                 counts) unless --allow-uncommitted says leave them be,
+//                 and when a worktree tip holds commits no remote backs
+//                 (they exist only on this machine) unless --allow-unbacked
+//                 records that the operator saw the counts and declined
+//                 the backup.
 //   --enable-task-model
 //                 flip workspace.sessionModel to "task" (accepts a task
 //                 worktree root — the one mode allowed off the launcher)
@@ -585,8 +589,9 @@ function readTracker(wsDir) {
       : rawRepos == null || rawRepos === '' ? [] : [String(rawRepos)];
     // A chat session with ended: null may still be open — session-start
     // records one per chat and session-end fills ended in. Counting them
-    // is how the inventory flags "a chat may be working in this session
-    // right now" before anyone proposes archiving it.
+    // is the raw material for the chat-open flag; whether the count means
+    // "a chat may be working here right now" is decided against the
+    // session's recency in inspectSession, not here.
     const chats = Array.isArray(fields.chatSessions) ? fields.chatSessions : [];
     const openChats = chats.filter((c) => c && typeof c === 'object' && (c.ended == null || c.ended === '')).length;
     return {
@@ -873,6 +878,14 @@ function inspectSession(gitFn, rootDir, sessionsDir, name, activeDays, now, fetc
   // mid-completion), while an unparseable file is tracker damage the
   // operator should hear about. Neither ever crashes the inspection.
   const trackerStripped = !existsSync(join(wsDir, 'session.md'));
+  // The tracker file's own mtime: a chat resuming the session rewrites
+  // session.md (the session-start hook registers it in chatSessions), so a
+  // fresh mtime is live-chat evidence even when no commit or reflog entry
+  // followed. It feeds only the chat-open question below, never
+  // lastActivity — an uncommitted tracker edit is bookkeeping, not work
+  // (same line dirtyContentMtimeMs draws).
+  let trackerMtimeMs = null;
+  try { trackerMtimeMs = statSync(join(wsDir, 'session.md')).mtimeMs; } catch { /* absent or unreadable — no signal */ }
   const rawWorktrees = collectSessionWorktrees(gitFn, rootDir, folder);
   const worktrees = rawWorktrees
     .filter((w) => w.kind !== 'foreign')
@@ -905,11 +918,36 @@ function inspectSession(gitFn, rootDir, sessionsDir, name, activeDays, now, fetc
 
   const { proposal, reasons } = classify({ name, worktrees, lastActivity, trackerStripped }, activeDays, now);
   const warnings = collectWarnings(gitFn, rootDir, worktrees, proposal === 'ACTIVE', tracker?.branch ?? null);
+  // A chat with no recorded end only means "may still be open" while
+  // something in the session is also recent: session-end misses often
+  // enough (a crashed chat, a skipped hook) that an entry sitting on a
+  // session idle for months is a stale record, not a live chat. Recency is
+  // the newest of the session's own activity signals (lastActivity —
+  // own-branch commits, reflog, dirty content, the tracker's updated
+  // field) and the tracker file's mtime. When no signal can establish
+  // either answer, the cautious reading stands.
+  let chatOpen = false;
+  let chatIdleDays = null;
   if (tracker && tracker.openChats > 0) {
-    warnings.push({
-      kind: 'chat-open',
-      message: `${tracker.openChats} chat session(s) recorded with no end time — a chat may still be working in this session; confirm with the operator before archiving it`,
-    });
+    const newestChatSignal = Math.max(
+      Number.isFinite(lastMs) ? lastMs : -Infinity,
+      trackerMtimeMs ?? -Infinity,
+    );
+    if (!Number.isFinite(newestChatSignal) || now - newestChatSignal <= activeDays * DAY_MS) {
+      chatOpen = true;
+      warnings.push({
+        kind: 'chat-open',
+        message: `${tracker.openChats} chat session(s) recorded with no end time — a chat may still be working in this session; confirm with the operator before archiving it`,
+      });
+    } else {
+      chatIdleDays = Math.floor((now - newestChatSignal) / DAY_MS);
+      warnings.push({
+        kind: 'chat-open-idle',
+        info: true,
+        idleDays: chatIdleDays,
+        message: `${tracker.openChats} chat session(s) recorded with no end time, but nothing in the session has moved for ${chatIdleDays} day(s) — the end was most likely never recorded; treat the chat as closed unless the operator knows otherwise`,
+      });
+    }
   }
   if (!trackerStripped && !tracker) {
     warnings.push({
@@ -922,7 +960,8 @@ function inspectSession(gitFn, rootDir, sessionsDir, name, activeDays, now, fetc
     kind: 'session',
     status: tracker?.status ?? null,
     workItem: tracker?.workItem ?? null,
-    chatOpen: tracker ? tracker.openChats > 0 : false,
+    chatOpen,
+    ...(chatIdleDays != null ? { chatIdleDays } : {}),
     lastActivity,
     proposal,
     reasons,
@@ -1753,12 +1792,17 @@ function repairAndVerify(gitFn, owned, worktreePaths, prunableBefore) {
  * find; a worktree holds uncommitted or untracked changes — an edited
  * session.md counts (unless allowUncommitted: they would ride along
  * fine, but they deserve a decision: commit them to the session branch,
- * or explicitly accept archiving them mid-edit); or the archive
- * directory is a symlink or resolves outside the workspace. If anything
- * fails after the rename, the folder is renamed back and repaired, and
- * the result reports the verified state.
+ * or explicitly accept archiving them mid-edit); or a worktree tip holds
+ * commits no remote backs — they exist only on this machine, and the
+ * archive is safe for them but the moment it is deleted they are gone
+ * (unless allowUnbacked, the operator's recorded decline after seeing
+ * the per-repo counts; the refusal names them, and a successful archive
+ * that carried unbacked tips reports them in `unbacked`). Also refused
+ * when the archive directory is a symlink or resolves outside the
+ * workspace. If anything fails after the rename, the folder is renamed
+ * back and repaired, and the result reports the verified state.
  */
-function archiveSession(root, { session, allowUncommitted = false, gitFn = spawnSync, cwd = process.cwd(), now = Date.now() } = {}) {
+function archiveSession(root, { session, allowUncommitted = false, allowUnbacked = false, gitFn = spawnSync, cwd = process.cwd(), now = Date.now() } = {}) {
   const rootDir = resolveRoot(root);
   if (!isSessionSegment(session)) {
     throw new Error(`session name must be a single path segment not starting with ".", got: ${session}`);
@@ -1824,6 +1868,30 @@ function archiveSession(root, { session, allowUncommitted = false, gitFn = spawn
       }
     }
   }
+  // Unpushed commits ride along safely too — but "safely" holds only as
+  // long as the archive exists, and deleting it later is the operator's
+  // own call. A tip whose commits no remote backs (the inventory's
+  // `unbacked` evidence, recomputed here at archive time) exists only on
+  // this machine, so the archive moves only once a remote holds every
+  // such tip — the backup step's push mode --remote with an allow — or
+  // after --allow-unbacked records that the operator saw these counts and
+  // declined it. allowUnbacked still reports what rode along.
+  const unbacked = [];
+  for (const f of found) {
+    const wtPath = f.rel === '.' ? folder : join(folder, f.rel);
+    const info = inspectWorktree(
+      gitFn, rootDir,
+      f.owner.repo === WORKSPACE_REPO ? 'workspace' : 'project',
+      f.owner.repo, wtPath, null,
+    );
+    if (info.ahead > 0 && !info.backedBy) unbacked.push(info);
+  }
+  if (unbacked.length > 0 && !allowUnbacked) {
+    reasons.push(
+      ...unbacked.map((wt) => unbackedMessage(gitFn, rootDir, wt)),
+      `${unbacked.length} worktree tip(s) above hold commits that exist only on this machine — this clears only when a remote holds them (--backup --remote with the operator's allow pushes backup tags there), or re-run with --allow-unbacked once the operator has seen these counts and explicitly declined the backup`,
+    );
+  }
   if (reasons.length > 0) return { refused: true, reasons };
 
   const archiveDir = join(sessionsDir, '.archived');
@@ -1867,6 +1935,9 @@ function archiveSession(root, { session, allowUncommitted = false, gitFn = spawn
     from: relative(rootDir, folder),
     to: relative(rootDir, dest),
     worktrees: at(dest).map((m) => ({ repo: m.owner.repo, path: relative(rootDir, m.path) })),
+    // What the operator accepted riding along unbacked — the same
+    // repos and counts the refusal would have named.
+    ...(unbacked.length > 0 ? { unbacked: unbacked.map((wt) => ({ repo: wt.repo, branch: wt.branch, commits: wt.ahead })) } : {}),
     warnings: scan.outwardLinks.map((l) => `relative symlink ${relative(rootDir, join(dest, relative(folder, l)))} pointed outside the session and no longer resolves after the move — it was kept as-is`),
   };
 }
@@ -1927,7 +1998,7 @@ function renderTable(result) {
       : s.kind === 'foreign' ? 'foreign entry' : s.proposal;
     const detail = s.kind === 'broken' || s.kind === 'foreign'
       ? ''
-      : `  (status ${s.status ?? '—'}, last activity ${s.lastActivity ?? '—'}, work item ${s.workItem ?? '—'}${s.chatOpen ? ', chat open?' : ''})`;
+      : `  (status ${s.status ?? '—'}, last activity ${s.lastActivity ?? '—'}, work item ${s.workItem ?? '—'}${s.chatOpen ? ', chat open?' : s.chatIdleDays != null ? `, chat: no end recorded (idle ${s.chatIdleDays}d)` : ''})`;
     lines.push(`${s.name}  ${header}${detail}`);
     for (const w of s.worktrees || []) {
       const remotes = Object.entries(w.remotes)
@@ -1952,7 +2023,9 @@ function renderTable(result) {
       }
     }
     for (const r of s.reasons || []) lines.push(`    · ${r}`);
-    for (const w of s.warnings || []) lines.push(`    ! ${w.message}`);
+    // `!` marks something to act on; an entry carrying info: true is
+    // context (a stale record explained, not a live risk).
+    for (const w of s.warnings || []) lines.push(`    ${w.info ? 'i' : '!'} ${w.message}`);
   }
   if (Array.isArray(result.externalWorktrees) && result.externalWorktrees.length > 0) {
     lines.push('');
@@ -1976,6 +2049,7 @@ const BOOL_FLAGS = new Map([
   ['--remote', 'remote'],
   ['--remote-allow-all', 'remoteAllowAll'],
   ['--allow-uncommitted', 'allowUncommitted'],
+  ['--allow-unbacked', 'allowUnbacked'],
   ['--fetch', 'fetch'],
 ]);
 
@@ -1990,6 +2064,7 @@ function parseArgs(argv) {
     remote: false,
     remoteAllowAll: false,
     allowUncommitted: false,
+    allowUnbacked: false,
     fetch: false,
   };
   const rest = argv.slice(2);
@@ -2045,6 +2120,9 @@ function parseArgs(argv) {
   if (args.allowUncommitted && args.mode !== 'archive') {
     throw new Error('--allow-uncommitted is only valid with --archive');
   }
+  if (args.allowUnbacked && args.mode !== 'archive') {
+    throw new Error('--allow-unbacked is only valid with --archive');
+  }
   if (args.dryRun && args.mode !== 'backup') {
     throw new Error('--dry-run is only valid with --backup');
   }
@@ -2073,7 +2151,11 @@ function main() {
       dryRun: args.dryRun,
     });
   } else if (args.mode === 'archive') {
-    out = archiveSession(rootDir, { session: args.session, allowUncommitted: args.allowUncommitted });
+    out = archiveSession(rootDir, {
+      session: args.session,
+      allowUncommitted: args.allowUncommitted,
+      allowUnbacked: args.allowUnbacked,
+    });
   } else {
     out = enableTaskModel(rootDir);
   }