snipara-companion 1.3.0 → 1.3.2

package/README.md

@@ -112,6 +112,14 @@ The mental model is intentionally close to Git:
 | `git format-patch` | `snipara-companion handoff`               |
 | `git checkout`     | `snipara-companion workflow resume`       |
 
+`snipara-companion final-commit` closes the local workflow and asks the hosted
+API only for the final Team Sync handoff. The CLI sends a compact summary with a
+longer timeout, retries once with a shorter summary on transient hosted failures,
+and then records a local fallback handoff in `.snipara/team-sync/session.json`
+if the hosted call still times out. A hosted final-commit timeout does not modify
+Git state. Custom final-commit categories are namespaced under `final-commit`
+before the hosted call so they stay on the handoff-only path.
+
 ## Verification Plans
 
 Use `verify` when an agent asks what to prove before handoff or release:
@@ -489,6 +497,7 @@ project API key, the same commands also call the hosted Team Sync surfaces:
 - `team-sync handoff` records the local handoff and publishes the hosted handoff capsule.
 - `team-sync what-changed` keeps local counters but also loads the hosted What Changed For Me surface.
 - `team-sync resume` and `workflow resume` append the latest hosted handoff plus checkpoint-aware resume context when available.
+- `team-sync sweep` archives local work items after 14 days without update by default; use `--dry-run` to review before changing the local continuity file.
 - Hosted MCP also exposes `snipara_resume_context` for agents that want the same continuity bundle directly: latest handoff match, What Changed, active decisions, execution-memory, and an optional task-scoped work brief.
 
 Typical flow:
@@ -497,6 +506,7 @@ Typical flow:
 snipara-companion team-sync start-work --summary "add invite permissions" --files apps/web/src/lib/auth/permissions.ts
 snipara-companion team-sync handoff --summary "moved project access check" --next "run permissions tests before merge" --attention proof
 snipara-companion team-sync what-changed
+snipara-companion team-sync sweep --dry-run
 snipara-companion workflow resume --include-session-context
 snipara-companion workflow phase-start implement-permissions
 ```
@@ -584,6 +594,7 @@ Semantics:
 - `snipara-companion team-sync start-work` = keeps the local session file and fetches the hosted Start Work Brief when the workspace has project auth
 - `snipara-companion team-sync handoff` = keeps the local handoff record and publishes the hosted handoff capsule when project auth is available
 - `snipara-companion team-sync what-changed` = prints the local state summary and the hosted What Changed For Me response when configured
+- `snipara-companion team-sync sweep` = archives stale local work items after an inactivity threshold; default is 14 days and `--dry-run` previews the cleanup
 - `snipara-companion team-sync resume` = reloads local carryover plus the hosted latest handoff and checkpoint-aware resume guidance when available
 - `snipara-companion final-commit` / `workflow final-commit` = final hosted commit for the managed workflow
 - `snipara-companion code symbol-card` = direct paid Context `snipara_code_symbol_card` for an important symbol before editing, with an agent guidance summary before raw JSON

package/dist/index.d.ts

@@ -949,6 +949,8 @@ declare class RLMClient {
         category?: string;
         outcome?: "completed" | "partial" | "blocked" | "abandoned";
         filesTouched?: string[];
+        persistTypes?: string[];
+        handoffOnly?: boolean;
     }): Promise<Record<string, unknown>>;
     journalAppend(text: string, tags?: string[]): Promise<JournalAppendResult>;
 }
@@ -1209,6 +1211,7 @@ interface AgenticWorkStatus {
     teamSync: {
         activeWorkCount: number;
         staleWorkCount: number;
+        archivedWorkCount: number;
         handoffCount: number;
         latestHandoff?: {
             summary: string;
@@ -1501,7 +1504,7 @@ declare function getAutomationStatus(projectDir?: string): AutomationStatusResul
 
 declare const TEAM_SYNC_STATE_RELATIVE_PATH: string;
 type TeamSyncAttention = "note" | "watch" | "review" | "proof";
-type TeamSyncWorkStatus = "active" | "completed";
+type TeamSyncWorkStatus = "active" | "completed" | "archived";
 interface TeamSyncRecordInput {
     summary: string;
     files?: string[];
@@ -1524,6 +1527,8 @@ interface TeamSyncWorkRecord {
     updatedAt: string;
     completedAt?: string;
     completionReason?: string;
+    archivedAt?: string;
+    archiveReason?: string;
 }
 interface TeamSyncHandoffRecord {
     id: string;
@@ -1545,18 +1550,50 @@ interface TeamSyncSummary {
     activeWorkCount: number;
     staleWorkCount: number;
     completedWorkCount: number;
+    archivedWorkCount: number;
     handoffCount: number;
     files: string[];
     latestActiveWork?: TeamSyncWorkRecord;
     latestStaleWork?: TeamSyncWorkRecord;
     latestCompletedWork?: TeamSyncWorkRecord;
+    latestArchivedWork?: TeamSyncWorkRecord;
     latestHandoff?: TeamSyncHandoffRecord;
 }
+interface TeamSyncCommandOptions {
+    id?: string;
+    summary?: string;
+    files?: string[];
+    branch?: string;
+    actor?: string;
+    next?: string;
+    attention?: string;
+    risk?: string;
+    since?: string;
+    dir?: string;
+    includeSessionContext?: boolean;
+    emitOrchestratorHandoff?: boolean;
+    autoRouteOrchestrator?: boolean;
+    orchestratorPolicySource?: string;
+    output?: string;
+    days?: string;
+    dryRun?: boolean;
+    json?: boolean;
+}
 interface HostedAttempt<T> {
     status: "skipped" | "ok" | "error";
     data?: T;
     error?: string;
 }
+interface TeamSyncSweepResult {
+    action: "sweep";
+    statePath: string;
+    dryRun: boolean;
+    thresholdDays: number;
+    thresholdMs: number;
+    archivedCount: number;
+    archivedWork: TeamSyncWorkRecord[];
+    summary: TeamSyncSummary;
+}
 interface AgenticHandoffArtifact {
     version: "snipara.agentic_handoff.v1";
     generatedAt: string;
@@ -1581,10 +1618,17 @@ declare function buildTeamSyncStartWorkRecord(input: TeamSyncRecordInput): TeamS
 declare function buildTeamSyncHandoffRecord(input: TeamSyncRecordInput): TeamSyncHandoffRecord;
 declare function createEmptyTeamSyncState(now?: Date): TeamSyncState;
 declare function buildTeamSyncSummary(state: TeamSyncState, since?: Date, now?: Date): TeamSyncSummary;
+declare function archiveInactiveTeamSyncWork(state: TeamSyncState, options?: {
+    now?: Date;
+    thresholdMs?: number;
+    dryRun?: boolean;
+}): TeamSyncSweepResult["archivedWork"];
+declare function autoArchiveTeamSyncState(rootDir?: string, now?: Date): TeamSyncSweepResult["archivedWork"];
 declare function loadTeamSyncState(rootDir?: string): TeamSyncState;
 declare function saveTeamSyncState(state: TeamSyncState, rootDir?: string): void;
 declare function getTeamSyncStatePath(rootDir?: string): string;
 declare function buildAgenticHandoffMarkdown(artifact: AgenticHandoffArtifact): string;
+declare function teamSyncSweepCommand(options: TeamSyncCommandOptions): Promise<void>;
 
 interface JournalCheckpointPayload {
     action: string;
@@ -1773,4 +1817,4 @@ interface WrittenOrchestratorHandoff {
 declare function buildOrchestratorHandoff(options: OrchestratorHandoffOptions): OrchestratorHandoffArtifact;
 declare function writeOrchestratorHandoff(options: OrchestratorHandoffOptions): WrittenOrchestratorHandoff;
 
-export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, TEAM_SYNC_STATE_RELATIVE_PATH, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildJournalCheckpointEntry, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProjectIntelligenceBrief, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, collectSyncDocuments, collectSyncDocumentsInput, createClient, createEmptyTeamSyncState, createLocalQueryCache, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, extractCommandFromToolInput, extractFilesFromToolInput, formatOrchestratorRecommendationReason, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getConfigPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, installAutomationBundle, listProjectsForApiKey, loadAutomationManifest, loadConfig, loadTeamSyncState, normalizeGuardTag, normalizeWorkflowPlanInput, projectIntelligenceBriefCommand, resolveQueryFromToolInput, runMemoryGuardCheck, saveConfig, saveTeamSyncState, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, verifyCommand, writeOrchestratorHandoff };
+export { AUTOMATION_MANIFEST_RELATIVE_PATH, AutomationInstallConflictError, AutomationUnsupportedHookBundleError, ORCHESTRATOR_HANDOFF_RELATIVE_PATH, TEAM_SYNC_STATE_RELATIVE_PATH, WORKFLOW_PLANS_RELATIVE_DIR, WORKFLOW_STATE_RELATIVE_PATH, archiveInactiveTeamSyncWork, autoArchiveTeamSyncState, buildAgenticHandoffMarkdown, buildAgenticTimeline, buildAgenticWorkStatus, buildAutomationInstallPlan, buildCanonicalEvent, buildJournalCheckpointEntry, buildOnboardFolderManifest, buildOrchestratorHandoff, buildProjectIntelligenceBrief, buildSyncDocumentsDryRun, buildTeamSyncHandoffRecord, buildTeamSyncStartWorkRecord, buildTeamSyncSummary, buildToolCallPayload, buildToolResultPayload, buildVerificationPlan, buildWorkflowPhaseCommitSummary, buildWorkflowPlanScaffold, categoryFromGuardTag, classifyToolResult, collectSyncDocuments, collectSyncDocumentsInput, createClient, createEmptyTeamSyncState, createLocalQueryCache, detectReleaseSurfacesFromFiles, detectRuntimeEnvironment, extractCommandFromToolInput, extractFilesFromToolInput, formatOrchestratorRecommendationReason, formatStuckGuardDecision, getAutomationManifestPath, getAutomationStatus, getConfigPath, getOrchestratorRecommendation, getPlanStepDisplayTitle, getStagedFiles, getStuckGuardInjection, getTeamSyncStatePath, installAutomationBundle, listProjectsForApiKey, loadAutomationManifest, loadConfig, loadTeamSyncState, normalizeGuardTag, normalizeWorkflowPlanInput, projectIntelligenceBriefCommand, resolveQueryFromToolInput, runMemoryGuardCheck, saveConfig, saveTeamSyncState, shouldSuggestOrchestratorForWorkflow, shouldSuggestRuntimeForWorkflow, teamSyncSweepCommand, verifyCommand, writeOrchestratorHandoff };

package/dist/index.js

@@ -38,6 +38,8 @@ __export(index_exports, {
   TEAM_SYNC_STATE_RELATIVE_PATH: () => TEAM_SYNC_STATE_RELATIVE_PATH,
   WORKFLOW_PLANS_RELATIVE_DIR: () => WORKFLOW_PLANS_RELATIVE_DIR,
   WORKFLOW_STATE_RELATIVE_PATH: () => WORKFLOW_STATE_RELATIVE_PATH,
+  archiveInactiveTeamSyncWork: () => archiveInactiveTeamSyncWork,
+  autoArchiveTeamSyncState: () => autoArchiveTeamSyncState,
   buildAgenticHandoffMarkdown: () => buildAgenticHandoffMarkdown,
   buildAgenticTimeline: () => buildAgenticTimeline,
   buildAgenticWorkStatus: () => buildAgenticWorkStatus,
@@ -91,6 +93,7 @@ __export(index_exports, {
   saveTeamSyncState: () => saveTeamSyncState,
   shouldSuggestOrchestratorForWorkflow: () => shouldSuggestOrchestratorForWorkflow,
   shouldSuggestRuntimeForWorkflow: () => shouldSuggestRuntimeForWorkflow,
+  teamSyncSweepCommand: () => teamSyncSweepCommand,
   verifyCommand: () => verifyCommand,
   writeOrchestratorHandoff: () => writeOrchestratorHandoff
 });
@@ -1301,7 +1304,8 @@ var RLMClient = class {
       category: args.category,
       outcome: args.outcome || "completed",
       files_touched: args.filesTouched || [],
-      persist_types: ["decision", "learning", "workflow"]
+      persist_types: args.persistTypes ?? ["decision", "learning", "workflow"],
+      ...args.handoffOnly !== void 0 ? { handoff_only: args.handoffOnly } : {}
     });
   }
   async journalAppend(text, tags) {
@@ -7049,6 +7053,7 @@ async function appendJournalCheckpoint(payload) {
 // src/commands/team-sync.ts
 var TEAM_SYNC_STATE_RELATIVE_PATH = path12.join(".snipara", "team-sync", "session.json");
 var TEAM_SYNC_STALE_WORK_MS = 48 * 60 * 60 * 1e3;
+var TEAM_SYNC_AUTO_ARCHIVE_WORK_MS = 14 * 24 * 60 * 60 * 1e3;
 function buildTeamSyncStartWorkRecord(input) {
   const createdAt = (input.now ?? /* @__PURE__ */ new Date()).toISOString();
   const files = normalizeFiles(input.files);
@@ -7094,6 +7099,7 @@ function buildTeamSyncSummary(state, since, now = /* @__PURE__ */ new Date()) {
   const activeWork = work.filter((item) => item.status === "active" && !isStaleWork(item, now));
   const staleWork = work.filter((item) => item.status === "active" && isStaleWork(item, now));
   const completedWork = work.filter((item) => item.status === "completed");
+  const archivedWork = work.filter((item) => item.status === "archived");
   const files = /* @__PURE__ */ new Set();
   for (const item of [...work, ...handoffs]) {
     for (const file of item.files) {
@@ -7104,14 +7110,45 @@ function buildTeamSyncSummary(state, since, now = /* @__PURE__ */ new Date()) {
     activeWorkCount: activeWork.length,
     staleWorkCount: staleWork.length,
     completedWorkCount: completedWork.length,
+    archivedWorkCount: archivedWork.length,
     handoffCount: handoffs.length,
     files: Array.from(files).sort(),
     latestActiveWork: activeWork[activeWork.length - 1],
     latestStaleWork: staleWork[staleWork.length - 1],
     latestCompletedWork: completedWork[completedWork.length - 1],
+    latestArchivedWork: archivedWork[archivedWork.length - 1],
     latestHandoff: handoffs[handoffs.length - 1]
   };
 }
+function archiveInactiveTeamSyncWork(state, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowIso2 = now.toISOString();
+  const thresholdMs = options.thresholdMs ?? TEAM_SYNC_AUTO_ARCHIVE_WORK_MS;
+  const thresholdDays = Math.round(thresholdMs / (24 * 60 * 60 * 1e3));
+  const candidates = state.work.filter(
+    (item) => item.status === "active" && now.getTime() - getWorkTimestamp(item) > thresholdMs
+  );
+  if (!options.dryRun) {
+    for (const item of candidates) {
+      item.status = "archived";
+      item.updatedAt = nowIso2;
+      item.archivedAt = nowIso2;
+      item.archiveReason = `No update for ${thresholdDays} day(s)`;
+    }
+    if (candidates.length > 0) {
+      state.updatedAt = nowIso2;
+    }
+  }
+  return candidates;
+}
+function autoArchiveTeamSyncState(rootDir = process.cwd(), now = /* @__PURE__ */ new Date()) {
+  const state = loadTeamSyncState(rootDir);
+  const archivedWork = archiveInactiveTeamSyncWork(state, { now });
+  if (archivedWork.length > 0) {
+    saveTeamSyncState(state, rootDir);
+  }
+  return archivedWork;
+}
 function loadTeamSyncState(rootDir = process.cwd()) {
   const statePath = getTeamSyncStatePath(rootDir);
   if (!fs13.existsSync(statePath)) {
@@ -7137,6 +7174,7 @@ function getTeamSyncStatePath(rootDir = process.cwd()) {
 async function teamSyncStartWorkCommand(options) {
   const rootDir = resolveRootDir(options.dir);
   const state = loadTeamSyncState(rootDir);
+  archiveInactiveTeamSyncWork(state);
   const branch = normalizeOptionalString(options.branch) ?? readGitValue2(rootDir, ["branch", "--show-current"]);
   const record = buildTeamSyncStartWorkRecord({
     summary: options.summary ?? "",
@@ -7202,6 +7240,7 @@ async function teamSyncStartWorkCommand(options) {
 }
 async function teamSyncHandoffCommand(options) {
   const rootDir = resolveRootDir(options.dir);
+  autoArchiveTeamSyncState(rootDir);
   const payload = await createTeamSyncHandoffPayload(rootDir, {
     ...options,
     summary: options.summary ?? ""
@@ -7210,6 +7249,7 @@ async function teamSyncHandoffCommand(options) {
 }
 async function createTeamSyncHandoffPayload(rootDir, options) {
   const state = loadTeamSyncState(rootDir);
+  archiveInactiveTeamSyncWork(state);
   const record = buildTeamSyncHandoffRecord({
     summary: options.summary,
     files: options.files,
@@ -7459,6 +7499,10 @@ async function teamSyncWhatChangedCommand(options) {
   const rootDir = resolveRootDir(options.dir);
   const since = parseSince(options.since);
   const state = loadTeamSyncState(rootDir);
+  const archivedWork = archiveInactiveTeamSyncWork(state);
+  if (archivedWork.length > 0) {
+    saveTeamSyncState(state, rootDir);
+  }
   const summary = buildTeamSyncSummary(state, since);
   const hosted = await maybeGetHostedWhatChanged(rootDir, {
     since: since?.toISOString(),
@@ -7506,10 +7550,14 @@ async function teamSyncWhatChangedCommand(options) {
 async function teamSyncCompleteWorkCommand(options) {
   const rootDir = resolveRootDir(options.dir);
   const state = loadTeamSyncState(rootDir);
+  const archivedWork = archiveInactiveTeamSyncWork(state);
   const now = (/* @__PURE__ */ new Date()).toISOString();
   const activeOrStale = state.work.filter((item) => item.status === "active");
   const record = options.id ? activeOrStale.find((item) => item.id === options.id) : activeOrStale[activeOrStale.length - 1];
   if (!record) {
+    if (archivedWork.length > 0) {
+      saveTeamSyncState(state, rootDir);
+    }
     throw new Error(
       options.id ? `No active Team Sync work item found for id ${options.id}` : "No active Team Sync work item to complete"
     );
@@ -7545,6 +7593,10 @@ async function teamSyncCompleteWorkCommand(options) {
 async function teamSyncResumeCommand(options) {
   const rootDir = resolveRootDir(options.dir);
   const state = loadTeamSyncState(rootDir);
+  const archivedWork = archiveInactiveTeamSyncWork(state);
+  if (archivedWork.length > 0) {
+    saveTeamSyncState(state, rootDir);
+  }
   const summary = buildTeamSyncSummary(state);
   const hosted = await maybeGetHostedResume(rootDir, {
     task: summary.latestActiveWork?.summary ?? summary.latestHandoff?.summary,
@@ -7592,6 +7644,31 @@ async function teamSyncResumeCommand(options) {
     options.json
   );
 }
+async function teamSyncSweepCommand(options) {
+  const rootDir = resolveRootDir(options.dir);
+  const thresholdDays = parsePositiveDays(options.days ?? "14");
+  const thresholdMs = thresholdDays * 24 * 60 * 60 * 1e3;
+  const state = loadTeamSyncState(rootDir);
+  const archivedWork = archiveInactiveTeamSyncWork(state, {
+    thresholdMs,
+    dryRun: Boolean(options.dryRun)
+  });
+  if (!options.dryRun && archivedWork.length > 0) {
+    saveTeamSyncState(state, rootDir);
+  }
+  const summary = buildTeamSyncSummary(state);
+  const payload = {
+    action: "sweep",
+    statePath: getTeamSyncStatePath(rootDir),
+    dryRun: Boolean(options.dryRun),
+    thresholdDays,
+    thresholdMs,
+    archivedCount: archivedWork.length,
+    archivedWork,
+    summary
+  };
+  printTeamSyncSweepResult(payload, options.json);
+}
 function printTeamSyncResult(payload, json) {
   if (json) {
     console.log(JSON.stringify(payload, null, 2));
@@ -7604,6 +7681,7 @@ function printTeamSyncResult(payload, json) {
   console.log(`Active work: ${summary.activeWorkCount}`);
   console.log(`Stale work: ${summary.staleWorkCount}`);
   console.log(`Completed work: ${summary.completedWorkCount}`);
+  console.log(`Archived work: ${summary.archivedWorkCount}`);
   console.log(`Handoffs: ${summary.handoffCount}`);
   if (summary.files.length > 0) {
     console.log(`Files: ${summary.files.slice(0, 8).join(", ")}`);
@@ -7617,6 +7695,9 @@ function printTeamSyncResult(payload, json) {
   if (summary.latestCompletedWork) {
     console.log(`Latest completed work: ${summary.latestCompletedWork.summary}`);
   }
+  if (summary.latestArchivedWork) {
+    console.log(`Latest archived work: ${summary.latestArchivedWork.summary}`);
+  }
   if (summary.latestHandoff) {
     console.log(`Latest handoff: ${summary.latestHandoff.summary}`);
     if (summary.latestHandoff.next) {
@@ -7666,6 +7747,25 @@ function printTeamSyncResult(payload, json) {
     }
   }
 }
+function printTeamSyncSweepResult(payload, json) {
+  if (json) {
+    console.log(JSON.stringify(payload, null, 2));
+    return;
+  }
+  console.log(payload.dryRun ? "Team Sync sweep preview" : "Team Sync sweep completed");
+  console.log(`State: ${payload.statePath}`);
+  console.log(`Threshold: ${payload.thresholdDays} day(s) without update`);
+  console.log(`Archived work: ${payload.archivedCount}`);
+  if (payload.archivedWork.length > 0) {
+    console.log(
+      `Items: ${formatList(
+        payload.archivedWork.map((item) => item.summary),
+        6
+      )}`
+    );
+  }
+  console.log(`Remaining stale work: ${payload.summary.staleWorkCount}`);
+}
 function printHostedWorkBrief(brief) {
   console.log("");
   console.log("Hosted Start Work Brief");
@@ -8054,13 +8154,22 @@ function normalizeWorkRecord(record) {
     files: normalizeFiles(parsed.files),
     branch: normalizeOptionalString(parsed.branch),
     actor: normalizeOptionalString(parsed.actor),
-    status: parsed.status === "completed" ? "completed" : "active",
+    status: parsed.status === "completed" || parsed.status === "archived" ? parsed.status : "active",
     createdAt,
     updatedAt,
     completedAt: normalizeOptionalString(parsed.completedAt),
-    completionReason: normalizeOptionalString(parsed.completionReason)
+    completionReason: normalizeOptionalString(parsed.completionReason),
+    archivedAt: normalizeOptionalString(parsed.archivedAt),
+    archiveReason: normalizeOptionalString(parsed.archiveReason)
   };
 }
+function parsePositiveDays(value) {
+  const days = Number.parseInt(value, 10);
+  if (!Number.isFinite(days) || days <= 0) {
+    throw new Error("--days must be a positive integer");
+  }
+  return days;
+}
 function parseSince(value) {
   if (!value) return void 0;
   const date = new Date(value);
@@ -8126,6 +8235,11 @@ var import_chalk5 = __toESM(require("chalk"));
 var DEFAULT_SESSION_CONTEXT_TOKENS = 1e3;
 var DEFAULT_FULL_WORKFLOW_CRITICAL_TOKENS = 2e3;
 var DEFAULT_SHARED_CONTEXT_TOKENS = 2e3;
+var TASK_COMMIT_TIMEOUT_MS = 3e4;
+var FINAL_COMMIT_TIMEOUT_MS = 9e4;
+var FINAL_COMMIT_RETRY_TIMEOUT_MS = 45e3;
+var FINAL_COMMIT_SUMMARY_MAX_CHARS = 1200;
+var FINAL_COMMIT_RETRY_SUMMARY_MAX_CHARS = 600;
 var SHARED_CONTEXT_INTENT_PATTERN = /\b(standard|standards|convention|conventions|guideline|guidelines|best practice|best practices|policy|policies|compliance|compliant|security rules|team rules|style guide|playbook|checklist)\b/i;
 var DOCUMENT_SYNC_FORMATS = {
   ".adoc": { kind: "DOC", format: "adoc" },
@@ -8361,6 +8475,52 @@ function toPreview(value, maxLength = 160) {
   }
   return "n/a";
 }
+function positiveIntegerEnv(name, fallback) {
+  const value = process.env[name];
+  if (!value) {
+    return fallback;
+  }
+  const parsed = Number.parseInt(value, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function compactWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function truncateText(value, maxLength) {
+  const normalized = compactWhitespace(value);
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  const suffix = " ... [truncated locally for hosted final-commit]";
+  return `${normalized.slice(0, Math.max(0, maxLength - suffix.length)).trimEnd()}${suffix}`;
+}
+function buildHostedFinalCommitSummary(args) {
+  const prefix = args.workflowId ? `Workflow ${args.workflowId}
+Final commit
+` : "";
+  const budget = Math.max(80, args.maxLength - prefix.length);
+  return `${prefix}${truncateText(args.summary, budget)}`;
+}
+function hostedCommitErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function shouldRetryHostedFinalCommit(error) {
+  const message = hostedCommitErrorMessage(error).toLowerCase();
+  if (error instanceof Error && error.name === "AbortError") {
+    return true;
+  }
+  return /abort|timeout|timed out|network|fetch|econn|etimedout|http 5\d\d/.test(message);
+}
+function isFinalCommitCategory(category) {
+  return Boolean(category?.toLowerCase().includes("final-commit"));
+}
+function normalizeFinalCommitCategory(category) {
+  const normalized = compactWhitespace(category ?? "");
+  if (!normalized) {
+    return "final-commit";
+  }
+  return isFinalCommitCategory(normalized) ? normalized : `final-commit:${normalized}`;
+}
 function getPlanStepDisplayTitle(step, index = 0) {
   if (typeof step === "string") {
     return toPreview(step);
@@ -10068,6 +10228,12 @@ function printSessionBootstrap(result, options) {
 function printTaskCommitResult(result) {
   printKeyValue("Tool:", "snipara_end_of_task_commit");
   printCompactObject(result, ["stored", "skipped", "status", "message"]);
+  const handoff = isRecord6(result.team_sync_handoff) ? result.team_sync_handoff : null;
+  if (handoff) {
+    const status = typeof handoff.status === "string" ? handoff.status : "unknown";
+    const memoryId = typeof handoff.memory_id === "string" ? ` (${handoff.memory_id})` : "";
+    printKeyValue("Team Sync handoff:", `${status}${memoryId}`);
+  }
   console.log("");
   printJson(result);
 }
@@ -11559,6 +11725,7 @@ function buildSuggestedAgenticNextAction(state, risks) {
 function buildAgenticWorkStatus(cwd = process.cwd()) {
   const state = readWorkflowState2(cwd);
   const git = readLocalGitState(cwd);
+  autoArchiveTeamSyncState(cwd);
   const teamSyncState = loadTeamSyncState(cwd);
   const teamSyncSummary = buildTeamSyncSummary(teamSyncState);
   const latestHandoff = latestTeamSyncHandoff(teamSyncState.handoffs);
@@ -11606,6 +11773,7 @@ function buildAgenticWorkStatus(cwd = process.cwd()) {
     teamSync: {
       activeWorkCount: teamSyncSummary.activeWorkCount,
       staleWorkCount: teamSyncSummary.staleWorkCount,
+      archivedWorkCount: teamSyncSummary.archivedWorkCount,
       handoffCount: teamSyncSummary.handoffCount,
       ...latestHandoff ? {
         latestHandoff: {
@@ -11656,6 +11824,7 @@ function printAgenticWorkStatus(status) {
   console.log(import_chalk5.default.bold("Team Sync"));
   console.log(`Active work: ${status.teamSync.activeWorkCount}`);
   console.log(`Stale work: ${status.teamSync.staleWorkCount}`);
+  console.log(`Archived work: ${status.teamSync.archivedWorkCount}`);
   console.log(`Handoffs: ${status.teamSync.handoffCount}`);
   if (status.teamSync.latestHandoff) {
     console.log(`Latest handoff: ${toPreview(status.teamSync.latestHandoff.summary, 120)}`);
@@ -12068,7 +12237,7 @@ function printWorkflowTeamSyncResume(result) {
 }
 async function commitTaskMemory(options) {
   ensureConfigured();
-  const client = createClient(3e4);
+  const client = createClient(TASK_COMMIT_TIMEOUT_MS);
   return client.endOfTaskCommit({
     summary: options.summary,
     category: options.category,
@@ -12076,6 +12245,101 @@ async function commitTaskMemory(options) {
     filesTouched: options.files
   });
 }
+function recordLocalFinalCommitHandoff(options) {
+  const rootDir = process.cwd();
+  autoArchiveTeamSyncState(rootDir);
+  const state = loadTeamSyncState(rootDir);
+  const record = buildTeamSyncHandoffRecord({
+    summary: truncateText(options.summary, FINAL_COMMIT_SUMMARY_MAX_CHARS),
+    files: options.files,
+    attention: options.outcome === "completed" ? "watch" : "proof",
+    next: options.outcome === "completed" ? "Review this local fallback handoff before starting follow-up work." : "Resolve the blocker captured in this local fallback handoff."
+  });
+  state.handoffs.push(record);
+  state.updatedAt = record.createdAt;
+  saveTeamSyncState(state, rootDir);
+  return {
+    status: "local_fallback",
+    record_id: record.id,
+    state_path: getTeamSyncStatePath(rootDir),
+    category: "team_sync_handoff",
+    source_session_id: "local-companion-fallback",
+    files: record.files,
+    error: options.error
+  };
+}
+async function commitFinalTaskMemory(options) {
+  ensureConfigured();
+  const category = normalizeFinalCommitCategory(options.category);
+  const attempts = [];
+  const primarySummary = buildHostedFinalCommitSummary({
+    workflowId: options.workflowId,
+    summary: options.summary,
+    maxLength: FINAL_COMMIT_SUMMARY_MAX_CHARS
+  });
+  const retrySummary = buildHostedFinalCommitSummary({
+    workflowId: options.workflowId,
+    summary: options.summary,
+    maxLength: FINAL_COMMIT_RETRY_SUMMARY_MAX_CHARS
+  });
+  const callHosted = async (summary, timeoutMs) => {
+    const client = createClient(timeoutMs);
+    const handoffOnly = isFinalCommitCategory(category);
+    return client.endOfTaskCommit({
+      summary,
+      category,
+      outcome: options.outcome,
+      filesTouched: options.files,
+      persistTypes: handoffOnly ? [] : ["decision", "learning", "workflow"],
+      handoffOnly
+    });
+  };
+  try {
+    return await callHosted(
+      primarySummary,
+      positiveIntegerEnv("SNIPARA_FINAL_COMMIT_TIMEOUT_MS", FINAL_COMMIT_TIMEOUT_MS)
+    );
+  } catch (error) {
+    attempts.push({
+      summary_chars: primarySummary.length,
+      error: hostedCommitErrorMessage(error)
+    });
+    if (shouldRetryHostedFinalCommit(error)) {
+      try {
+        return await callHosted(
+          retrySummary,
+          positiveIntegerEnv("SNIPARA_FINAL_COMMIT_RETRY_TIMEOUT_MS", FINAL_COMMIT_RETRY_TIMEOUT_MS)
+        );
+      } catch (retryError) {
+        attempts.push({
+          summary_chars: retrySummary.length,
+          error: hostedCommitErrorMessage(retryError)
+        });
+      }
+    }
+  }
+  const lastError = attempts[attempts.length - 1]?.error ?? "hosted final-commit failed";
+  const localHandoff = recordLocalFinalCommitHandoff({
+    summary: options.summary,
+    outcome: options.outcome,
+    files: options.files,
+    error: lastError
+  });
+  return {
+    stored_count: 0,
+    skipped_count: 0,
+    candidates: [],
+    stored_candidates: [],
+    skipped_candidates: [],
+    team_sync_handoff: localHandoff,
+    hosted_final_commit: {
+      status: "error",
+      attempts,
+      message: "Hosted snipara_end_of_task_commit failed; local workflow state and Team Sync fallback handoff were preserved."
+    },
+    message: "Hosted final-commit failed; local fallback handoff created"
+  };
+}
 function printJournalWarning(result) {
   if (result?.status === "error" && result.error) {
     console.log(`Journal checkpoint: ${result.error}`);
@@ -12149,10 +12413,11 @@ async function finalCommitCommand(options) {
   });
   const state = readWorkflowState2();
   const outcome = options.outcome ?? "completed";
-  const summary = state ? [`Workflow ${state.workflowId}`, "Final commit", options.summary].join("\n") : options.summary;
-  const result = await commitTaskMemory({
-    summary,
-    category: options.category ?? "final-commit",
+  const category = normalizeFinalCommitCategory(options.category);
+  const result = await commitFinalTaskMemory({
+    workflowId: state?.workflowId,
+    summary: options.summary,
+    category,
     outcome,
     files: options.files
   });
@@ -12162,7 +12427,7 @@ async function finalCommitCommand(options) {
     state.currentPhaseId = outcome === "completed" ? void 0 : state.currentPhaseId;
     state.updatedAt = now;
     state.lastCommit = {
-      category: options.category ?? "final-commit",
+      category,
       outcome,
       summary: options.summary,
       committedAt: now
@@ -13171,6 +13436,14 @@ teamSync.command("complete-work").description("Close a local Team Sync work item
     json: options.json
   });
 });
+teamSync.command("sweep").description("Archive stale local Team Sync work items after an inactivity threshold").option("--days <days>", "Archive active work with no update after this many days", "14").option("--dry-run", "Preview which work items would be archived").option("-d, --dir <directory>", "Repository directory (default: current)").option("--json", "Print raw JSON").action(async (options) => {
+  await teamSyncSweepCommand({
+    days: options.days,
+    dryRun: Boolean(options.dryRun),
+    dir: options.dir,
+    json: options.json
+  });
+});
 teamSync.command("what-changed").description(
   "Summarize local Team Sync state and fetch hosted What Changed For Me when available"
 ).option("--since <date>", "Only include records created after this ISO date").option("-d, --dir <directory>", "Repository directory (default: current)").option(
@@ -13406,6 +13679,8 @@ if (require.main === module) {
   TEAM_SYNC_STATE_RELATIVE_PATH,
   WORKFLOW_PLANS_RELATIVE_DIR,
   WORKFLOW_STATE_RELATIVE_PATH,
+  archiveInactiveTeamSyncWork,
+  autoArchiveTeamSyncState,
   buildAgenticHandoffMarkdown,
   buildAgenticTimeline,
   buildAgenticWorkStatus,
@@ -13459,6 +13734,7 @@ if (require.main === module) {
   saveTeamSyncState,
   shouldSuggestOrchestratorForWorkflow,
   shouldSuggestRuntimeForWorkflow,
+  teamSyncSweepCommand,
   verifyCommand,
   writeOrchestratorHandoff
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "snipara-companion",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "Snipara Git-style companion CLI for hosted context, agent continuity, hooks, and automation workflows",
   "main": "dist/index.js",
   "bin": {