@useshifu/coding-harness 0.3.0 → 0.3.2

package/README.md

@@ -1,6 +1,6 @@
 # Shifu coding-harness connector
 
-`@useshifu/coding-harness` connects Codex, Claude Code, or OpenCode to Shifu. It reads local final-assistant notes, never user prompts or raw transcripts, and sends incremental redacted activity through durable checkpoints. Unattended runs emit controlled use-case labels rather than copying source prose.
+`@useshifu/coding-harness` connects Codex, Claude Code, or OpenCode to Shifu and watches one local input folder. Coding-session sync reads final-assistant notes, never user prompts or raw transcripts, and sends incremental redacted activity through durable checkpoints. Folder files are sent over TLS for server-side parsing, sanitization, and user-attribution checks; the local runner does not redact file contents.
 
 ## Connect
 
@@ -8,15 +8,22 @@
 npx @useshifu/coding-harness connect --harness <codex|claude_code|opencode>
 ```
 
-Connect installs the local instruction and scheduled runner, saves the connection key with owner-only permissions, and asks for two setup choices:
+Connect installs the local instruction and scheduled runner, saves the connection key with owner-only permissions, and uses these defaults without setup questions:
 
-- sync interval: four hours by default, configurable from 0.25 to 720 hours;
-- approval mode: automatic by default, or manual for one approval covering the accumulated queue.
+- sync interval: one hour, configurable from 0.25 to 720 hours;
+- automatic coding-session sync (manual approval remains available for coding sessions);
+- one input folder created at `~/Desktop/Shifu` on macOS, with a `README.md` explaining what it is for and shortcuts at `~/Downloads/Shifu` and `~/Documents/Shifu` when those parent folders exist.
 
-No session content is sent during setup. Re-running `connect` on an older installation keeps its key and checkpoints and completes the missing onboarding. Change the choices later with:
+Place `.txt`, `.md`, `.rtf`, or `.docx` files directly in the input folder. Its `README.md` is never synced and an existing one is not overwritten. Screenshots and images are not processed. Existing files are picked up on the next scheduled run; unchanged files are not sent again. A failed file stays pending for retry. Folder files never require a claim-review step, even when coding-session sync is in manual mode. Shifu creates claims only when the file supports a specific contribution by the connected user; meeting action items or another person's work are not treated as the user's claims.
+
+For named meeting transcripts, set your display name in Shifu Profile so your speaker turns can be identified. If the speaker cannot be matched, uncertain contributions are skipped.
+
+The shortcuts are symlinks to the same folder, not additional watched folders. An existing conflicting `Shifu` item is left untouched and reported. To choose another existing, readable folder, use `--input-folder <path>` with `connect` or `config update`; Shifu checks the path before saving the change. No macOS permission flow is required by the CLI.
+
+No content is sent during setup. Re-running `connect` on an older installation keeps its key, checkpoints, and selected sync policy. Change the choices later with:
 
 ```sh
-npx @useshifu/coding-harness config update --harness <codex|claude_code|opencode>
+npx @useshifu/coding-harness config update --harness <codex|claude_code|opencode> --interval-hours 1 --approval-mode automatic --input-folder ~/Desktop/Shifu
 ```
 
 Older configuration files remain on-demand and manual until either command completes onboarding; upgrading the package alone never enables background upload.
@@ -29,10 +36,13 @@ npx @useshifu/coding-harness sessions --harness codex --hours 24
 npx @useshifu/coding-harness review --harness codex --session-ref opaque-session-id
 npx @useshifu/coding-harness pending --harness codex
 npx @useshifu/coding-harness approve --harness codex
+npx @useshifu/coding-harness sync-files --harness codex
 ```
 
 Automatic scheduled runs send each accepted segment and advance its local checkpoint only after the server returns a matching receipt. Manual scheduled runs rebuild an accumulated local queue without advancing checkpoints and create or resume one content-free harness session when the pending count changes; one approval sends the queue in order. Network failures and server throttling are retried, while rejected segments stay pending.
 
+The same scheduled run checks the input folder. `sync-files` checks it immediately without changing the schedule. It sends supported file bytes over the configured HTTPS connection (or localhost HTTP for development); the server keeps the raw bytes transient and returns a final processing receipt before the local file checkpoint advances. Files larger than 5 MB are left pending with an error. The scanner reads regular files directly in the chosen folder and ignores symlinks and subfolders.
+
 The connector captures any useful harness activity, including engineering, product discovery, writing, interview feedback, research, and planning. Version-four payloads support generic `activity` items without a technical scope and accept a safe session-level summary when no item survives redaction. Version 1–3 clients remain supported.
 
 ## Sync a prepared payload

package/bin/shifu-harness.js

@@ -35,11 +35,24 @@ const MAX_TITLE_LENGTH = 160;
 const MAX_WORK_DETAIL_LENGTH = 600;
 const CONFIG_VERSION = 2;
 const REDACTION_VERSION = 4;
-const DEFAULT_INTERVAL_HOURS = 4;
+const DEFAULT_INTERVAL_HOURS = 1;
+const LEGACY_INTERVAL_HOURS = 4;
 const MIN_INTERVAL_HOURS = 0.25;
 const MAX_INTERVAL_HOURS = 720;
 const SCHEDULER_TICK_MINUTES = 15;
 const MAX_RETRIES = 4;
+const MAX_WORK_FILE_BYTES = 5 * 1024 * 1024;
+const WORK_FILE_SYNC_VERSION = 2;
+const WORK_FILE_EXTENSIONS = new Set([".txt", ".md", ".rtf", ".docx"]);
+const INPUT_FOLDER_README_NAME = "README.md";
+const INPUT_FOLDER_README = `# Shifu sync folder
+
+Put work logs, meeting transcripts, and other work documents directly in this folder. Shifu checks it every hour by default and keeps claims only when the file supports a contribution you made. Other people's work and meeting action items alone are not your claims.
+
+Supported files: .txt, .md, .rtf, and .docx. Subfolders, links, images, and screenshots are not processed. This README is not synced.
+
+Files you add are sent to Shifu for parsing and sanitization; they are not redacted on this device. Only place files here if you want them processed. For named meeting transcripts, set your display name in Shifu Profile so your speaker turns can be matched.
+`;
 
 function configRoot() {
   return process.env.SHIFU_CONFIG_ROOT || path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config"), "shifu", "coding-harness");
@@ -204,7 +217,7 @@ function normalizedPolicy(config) {
     (approvalMode === "automatic" || approvalMode === "manual");
   return {
     onboardingComplete: configured,
-    intervalHours: configured ? interval : DEFAULT_INTERVAL_HOURS,
+    intervalHours: configured ? interval : LEGACY_INTERVAL_HOURS,
     approvalMode: configured ? approvalMode : "manual",
     scheduleEnabled: configured ? config.syncPolicy.scheduleEnabled !== false : false,
     excludedSessionRefs: Array.isArray(config?.syncPolicy?.excludedSessionRefs) ? config.syncPolicy.excludedSessionRefs.filter(sessionRefIsSafe) : [],
@@ -252,6 +265,59 @@ function readState(harness) {
   return readJSON(statePath(harness), { sessions: {} });
 }
 
+function defaultInputFolder(home = os.homedir()) {
+  return path.join(home, "Desktop", "Shifu");
+}
+
+function configuredInputFolder(config, selected = option("--input-folder")) {
+  const value = selected || config?.inputFolder || defaultInputFolder();
+  return path.resolve(value.startsWith("~/") ? path.join(os.homedir(), value.slice(2)) : value);
+}
+
+function validateInputFolder(folder) {
+  let stat;
+  try {
+    stat = fs.statSync(folder);
+  } catch {
+    throw new Error(`The Shifu input folder is not accessible: ${folder}`);
+  }
+  if (!stat.isDirectory()) throw new Error(`The Shifu input path is not a folder: ${folder}`);
+  try {
+    fs.accessSync(folder, fs.constants.R_OK | fs.constants.X_OK);
+  } catch {
+    throw new Error(`The Shifu input folder is not accessible: ${folder}`);
+  }
+  return folder;
+}
+
+function prepareInputFolder(folder, isDefault = false, platform = process.env.SHIFU_PLATFORM || process.platform, home = os.homedir()) {
+  if (isDefault) fs.mkdirSync(folder, { recursive: true, mode: 0o700 });
+  validateInputFolder(folder);
+  if (isDefault) {
+    try {
+      fs.writeFileSync(path.join(folder, INPUT_FOLDER_README_NAME), INPUT_FOLDER_README, { flag: "wx", mode: 0o600 });
+    } catch (error) {
+      if (error?.code !== "EEXIST") throw error;
+    }
+  }
+  const conflicts = [];
+  if (platform === "darwin") {
+    for (const location of ["Downloads", "Documents"]) {
+      const parent = path.join(home, location);
+      if (!fs.existsSync(parent)) continue;
+      const alias = path.join(parent, "Shifu");
+      try {
+        const existing = fs.lstatSync(alias);
+        if (!existing.isSymbolicLink() || path.resolve(parent, fs.readlinkSync(alias)) !== folder) conflicts.push(alias);
+      } catch (error) {
+        if (error?.code !== "ENOENT") throw error;
+        fs.symlinkSync(folder, alias, "dir");
+      }
+    }
+  }
+  return conflicts;
+}
+
 function saveState(harness, state) {
   writeJSON(statePath(harness), state);
 }
@@ -595,17 +661,6 @@ async function confirm(question) {
   }
 }
 
-async function ask(question, fallback) {
-  const terminal = prompt();
-  try {
-    const answer = (await terminal.question(`${question} [${fallback}] `)).trim();
-    return answer || fallback;
-  } finally {
-    terminal.close();
-    if (terminal.shifuInput !== process.stdin) terminal.shifuInput.destroy();
-  }
-}
-
 async function readSecret(input = process.stdin) {
   const ownsInput = !input.isTTY;
   if (ownsInput) input = new tty.ReadStream(fs.openSync(process.platform === "win32" ? "CONIN$" : "/dev/tty", "r"));
@@ -799,13 +854,10 @@ function scheduleNextRun(harness, intervalHours) {
 async function chooseSyncPolicy(existing) {
   const intervalOption = option("--interval-hours");
   const approvalOption = option("--approval-mode");
-  const intervalHours = validateIntervalHours(intervalOption ?? await ask("Sync every how many hours?", String(existing.intervalHours || DEFAULT_INTERVAL_HOURS)));
-  let approvalMode = approvalOption;
-  if (approvalMode === undefined) {
-    const answer = (await ask("Approval mode: automatic or manual?", existing.approvalMode || "automatic")).toLowerCase();
-    approvalMode = answer === "auto" ? "automatic" : answer;
-  }
-  return { intervalHours, approvalMode: validateApprovalMode(approvalMode) };
+  return {
+    intervalHours: validateIntervalHours(intervalOption ?? existing.intervalHours ?? DEFAULT_INTERVAL_HOURS),
+    approvalMode: validateApprovalMode(approvalOption ?? existing.approvalMode ?? "automatic"),
+  };
 }
 
 async function connect(harness) {
@@ -817,12 +869,16 @@ async function connect(harness) {
   const currentPolicy = savedPolicy?.onboardingComplete ? savedPolicy : { intervalHours: DEFAULT_INTERVAL_HOURS, approvalMode: "automatic", excludedSessionRefs: savedPolicy?.excludedSessionRefs || [] };
   const selected = await chooseSyncPolicy(currentPolicy);
   const syncPolicy = configuredSyncPolicy(existing || {}, harness, selected.intervalHours, selected.approvalMode);
+  const inputFolder = configuredInputFolder(existing);
+  const conflicts = prepareInputFolder(inputFolder, inputFolder === defaultInputFolder());
   install(harness, true);
   const scheduleFile = installSchedule(harness);
-  writeJSON(configPath(harness), { ...existing, version: CONFIG_VERSION, apiUrl, token, harness, syncPolicy });
+  writeJSON(configPath(harness), { ...existing, version: CONFIG_VERSION, apiUrl, token, harness, syncPolicy, inputFolder });
   scheduleNextRun(harness, syncPolicy.intervalHours);
   console.error(`${HARNESS_NAMES[harness]} is connected. It will sync every ${syncPolicy.intervalHours} hours with ${syncPolicy.approvalMode} approval.`);
-  console.error(`Schedule installed at ${scheduleFile}. No session content was sent during setup.`);
+  console.error(`Shifu sync folder: ${inputFolder}. Place .txt, .md, .rtf, or .docx files there. Only grounded contributions will become claims.`);
+  if (conflicts.length) console.error(`Existing Shifu shortcut(s) were left unchanged: ${conflicts.join(", ")}.`);
+  console.error(`Schedule installed at ${scheduleFile}. No content was sent during setup.`);
 }
 
 async function updateConfig(harness) {
@@ -830,13 +886,18 @@ async function updateConfig(harness) {
   const savedPolicy = normalizedPolicy(config);
   const selected = await chooseSyncPolicy(savedPolicy.onboardingComplete ? savedPolicy : { intervalHours: DEFAULT_INTERVAL_HOURS, approvalMode: "automatic" });
   const scheduleEnabled = option("--schedule") !== "off";
+  const inputFolder = configuredInputFolder(config);
+  const conflicts = prepareInputFolder(inputFolder, inputFolder === defaultInputFolder());
   config.version = CONFIG_VERSION;
   config.syncPolicy = configuredSyncPolicy(config, harness, selected.intervalHours, selected.approvalMode, scheduleEnabled);
+  config.inputFolder = inputFolder;
   install(harness, true);
   if (scheduleEnabled) installSchedule(harness);
   writeJSON(configPath(harness), config);
   scheduleNextRun(harness, config.syncPolicy.intervalHours);
   console.error(`${HARNESS_NAMES[harness]} now syncs every ${config.syncPolicy.intervalHours} hours with ${config.syncPolicy.approvalMode} approval${scheduleEnabled ? "" : "; scheduling is off"}.`);
+  console.error(`Input folder: ${inputFolder}.`);
+  if (conflicts.length) console.error(`Existing Shifu shortcut(s) were left unchanged: ${conflicts.join(", ")}.`);
 }
 
 function textIsSafe(value, maximum) {
@@ -929,6 +990,89 @@ async function postSync(config, input) {
   throw lastError;
 }
 
+function workFiles(folder) {
+  return fs.readdirSync(validateInputFolder(folder), { withFileTypes: true })
+    .filter((entry) => entry.isFile() && entry.name !== INPUT_FOLDER_README_NAME && WORK_FILE_EXTENSIONS.has(path.extname(entry.name).toLowerCase()))
+    .map((entry) => path.join(folder, entry.name))
+    .sort();
+}
+
+function readWorkFile(file) {
+  const descriptor = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  try {
+    const before = fs.fstatSync(descriptor);
+    if (!before.isFile() || before.size > MAX_WORK_FILE_BYTES) throw new Error("Only regular files up to 5 MB are supported.");
+    const bytes = fs.readFileSync(descriptor);
+    const after = fs.fstatSync(descriptor);
+    if (bytes.length > MAX_WORK_FILE_BYTES || before.size !== after.size || before.mtimeMs !== after.mtimeMs) {
+      throw new Error("The file changed while being read; it will be retried later.");
+    }
+    return { bytes, modifiedAt: after.mtime.toISOString(), sha256: createHash("sha256").update(bytes).digest("hex") };
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+async function postWorkFile(config, file, contents) {
+  let lastError;
+  for (let attempt = 0; attempt < MAX_RETRIES; attempt += 1) {
+    let response;
+    try {
+      const form = new FormData();
+      form.append("file", new Blob([contents.bytes]), path.basename(file));
+      form.append("sourceModifiedAt", contents.modifiedAt);
+      response = await fetch(`${config.apiUrl}/v1/connectors/work-files`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${config.token}` },
+        body: form,
+        signal: AbortSignal.timeout(15 * 60_000),
+      });
+    } catch (error) {
+      lastError = new Error(`Could not send ${path.basename(file)} to Shifu: ${error?.cause?.code || error?.message || "unknown transport error"}.`);
+      if (attempt + 1 < MAX_RETRIES) await sleep(retryDelay(undefined, attempt));
+      continue;
+    }
+    const payload = await response.json().catch(() => undefined);
+    if (response.ok) {
+      const receipt = payload?.data;
+      if (["processed", "no_claims", "duplicate"].includes(receipt?.status) && Number.isInteger(receipt?.claimsCreated) && receipt.claimsCreated >= 0) return receipt;
+      throw new Error(`Shifu returned an invalid receipt for ${path.basename(file)}. Local state was not advanced.`);
+    }
+    lastError = new Error(payload?.error?.message || `Shifu rejected ${path.basename(file)} (${response.status}).`);
+    if (response.status !== 429 && response.status < 500) throw lastError;
+    if (attempt + 1 < MAX_RETRIES) await sleep(retryDelay(response, attempt));
+  }
+  throw lastError;
+}
+
+async function syncWorkFiles(harness, config = readConfig(harness)) {
+  if (typeof config.inputFolder !== "string") throw new Error("No input folder is configured. Run connect again to enable file sync.");
+  const folder = validateInputFolder(configuredInputFolder(config));
+  const state = readState(harness);
+  const prior = state.workFiles?.folder === folder && state.workFiles.version === WORK_FILE_SYNC_VERSION ? state.workFiles.files || {} : {};
+  let synced = 0;
+  let failures = 0;
+  for (const file of workFiles(folder)) {
+    const name = path.basename(file);
+    try {
+      const contents = readWorkFile(file);
+      if (prior[name] === contents.sha256) continue;
+      const receipt = await postWorkFile(config, file, contents);
+      const latest = readState(harness);
+      const files = latest.workFiles?.folder === folder && latest.workFiles.version === WORK_FILE_SYNC_VERSION ? latest.workFiles.files || {} : {};
+      latest.workFiles = { folder, version: WORK_FILE_SYNC_VERSION, files: { ...files, [name]: contents.sha256 } };
+      saveState(harness, latest);
+      prior[name] = contents.sha256;
+      synced += 1;
+      console.error(`${name}: ${receipt.status} (${receipt.claimsCreated} claim${receipt.claimsCreated === 1 ? "" : "s"}).`);
+    } catch (error) {
+      failures += 1;
+      console.error(`${name} remains pending: ${error.message}`);
+    }
+  }
+  return { synced, failures };
+}
+
 async function sendSync(harness, input, config = readConfig(harness)) {
   validateSync(input, harness);
   const state = readState(harness);
@@ -949,6 +1093,7 @@ async function withSyncLock(harness, action) {
   fs.mkdirSync(configRoot(), { recursive: true, mode: 0o700 });
   const file = lockPath(harness);
   let descriptor;
+  let heartbeat;
   try {
     try {
       descriptor = fs.openSync(file, "wx", 0o600);
@@ -960,8 +1105,13 @@ async function withSyncLock(harness, action) {
       descriptor = fs.openSync(file, "wx", 0o600);
     }
     fs.writeFileSync(descriptor, `${process.pid}\n`);
+    heartbeat = setInterval(() => {
+      try { fs.futimesSync(descriptor, new Date(), new Date()); } catch {}
+    }, 60_000);
+    heartbeat.unref();
     return await action();
   } finally {
+    if (heartbeat) clearInterval(heartbeat);
     if (descriptor !== undefined) {
       fs.closeSync(descriptor);
       try { fs.unlinkSync(file); } catch {}
@@ -1073,6 +1223,18 @@ async function scheduledSync(harness) {
     const startedAt = Date.now();
     let failures = 0;
     let synced = 0;
+    let syncedFiles = 0;
+    let failedFiles = 0;
+    if (config.inputFolder) {
+      try {
+        const files = await syncWorkFiles(harness, config);
+        failedFiles = files.failures;
+        syncedFiles = files.synced;
+      } catch (error) {
+        failedFiles = 1;
+        console.error(`Shifu input folder remains pending: ${error.message}`);
+      }
+    }
     if (policy.approvalMode === "manual") {
       const queue = rebuildPendingQueue(harness);
       const pendingFingerprint = createHash("sha256").update(queue.segments.map((segment) => `${segment.sessionRef}:${segment.fromTurn}:${segment.toTurn}`).join("\n")).digest("hex");
@@ -1093,12 +1255,14 @@ async function scheduledSync(harness) {
       state.schedule = {
         ...state.schedule,
         lastAttemptAt: startedAt,
-        lastResult: notificationError ? "awaiting_approval_notification_failed" : "awaiting_approval",
+        lastResult: notificationError ? "awaiting_approval_notification_failed" : failedFiles ? "partial_failure" : "awaiting_approval",
+        syncedFiles,
+        failedFiles,
         pendingSegments: queue.segments.length,
         pendingFingerprint,
         approvalSessionRef,
         notificationError,
-        nextRunAt: startedAt + (notificationError ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
+        nextRunAt: startedAt + (notificationError || failedFiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
       };
     } else {
       const blockedSessions = new Set();
@@ -1115,10 +1279,12 @@ async function scheduledSync(harness) {
       }
       state.schedule = {
         lastAttemptAt: startedAt,
-        lastResult: failures ? "partial_failure" : "complete",
+        lastResult: failures || failedFiles ? "partial_failure" : "complete",
         syncedSegments: synced,
         failedSessions: failures,
-        nextRunAt: startedAt + (failures ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
+        syncedFiles,
+        failedFiles,
+        nextRunAt: startedAt + (failures || failedFiles ? SCHEDULER_TICK_MINUTES / 60 : policy.intervalHours) * 3_600_000,
       };
     }
     const latest = readState(harness);
@@ -1132,7 +1298,14 @@ function status(harness) {
   const config = readConfig(harness);
   const state = readState(harness);
   const pending = readJSON(pendingPath(harness), { segments: [] });
-  console.log(JSON.stringify({ harness, apiUrl: config.apiUrl, syncPolicy: normalizedPolicy(config), schedule: state.schedule || null, pendingSegments: pending.segments.length, sessions: state.sessions }, null, 2));
+  console.log(JSON.stringify({ harness, apiUrl: config.apiUrl, inputFolder: config.inputFolder || null, syncPolicy: normalizedPolicy(config), schedule: state.schedule || null, pendingSegments: pending.segments.length, syncedFiles: Object.keys(state.workFiles?.files || {}).length, sessions: state.sessions }, null, 2));
+}
+
+async function syncFilesNow(harness) {
+  const result = await withSyncLock(harness, () => syncWorkFiles(harness));
+  if (result?.skipped) throw new Error("Another Shifu sync is already running. Files remain pending.");
+  console.error(`Checked the input folder: ${result.synced} sent, ${result.failures} pending.`);
+  if (result.failures) throw new Error("Some input files remain pending. Retry sync-files after resolving the errors above.");
 }
 
 function sessions(harness) {
@@ -1192,13 +1365,14 @@ async function main() {
   if (command === "connect") return connect(harness);
   if (command === "config" && subCommand === "update") return updateConfig(harness);
   if (command === "sync") return sync(harness);
+  if (command === "sync-files") return syncFilesNow(harness);
   if (command === "scheduled-sync") return scheduledSync(harness);
   if (command === "pending") return showPending(harness);
   if (command === "approve") return approvePending(harness);
   if (command === "status") return status(harness);
   if (command === "sessions" || command === "discover" || (command === "session" && (subCommand === "discover" || subCommand === "list" || !subCommand || subCommand.startsWith("-")))) return sessions(harness);
   if (command === "review") return review(harness);
-  throw new Error("Use install, connect, config update, status, sessions, review, sync, pending, approve, or scheduled-sync.");
+  throw new Error("Use install, connect, config update, status, sessions, review, sync, sync-files, pending, approve, or scheduled-sync.");
 }
 
 if (require.main === module) {
@@ -1210,4 +1384,4 @@ if (require.main === module) {
     });
 }
 
-module.exports = { approvalNotificationInvocation, claudeReview, claudeSession, codexReview, codexSession, configPath, configuredSyncPolicy, finalAssistantNote, install, installDestination, localSessions, normalizedPolicy, notificationSessionRef, opencodeQuery, opencodeReview, opencodeSessions, payloadForSegment, pendingSegments, readSecret, removeHooks, requireSafeApiUrl, reviewCandidates, schedulerArtifact, statePath, textIsSafe, unsyncedCodexSessions, validSyncReceipt, validateApprovalMode, validateIntervalHours, validateSync };
+module.exports = { approvalNotificationInvocation, claudeReview, claudeSession, codexReview, codexSession, configPath, configuredSyncPolicy, defaultInputFolder, finalAssistantNote, install, installDestination, localSessions, normalizedPolicy, notificationSessionRef, opencodeQuery, opencodeReview, opencodeSessions, payloadForSegment, pendingSegments, prepareInputFolder, readSecret, removeHooks, requireSafeApiUrl, reviewCandidates, schedulerArtifact, statePath, syncWorkFiles, textIsSafe, unsyncedCodexSessions, validateInputFolder, validSyncReceipt, validateApprovalMode, validateIntervalHours, validateSync, workFiles };

package/commands/shifu-sync.md

@@ -4,6 +4,8 @@ description: Inspect or sync redacted OpenCode activity using the saved Shifu po
 
 Run `npx @useshifu/coding-harness status --harness opencode` first.
 
+For an explicit Shifu input-folder sync, run `sync-files --harness opencode`. It processes supported `.txt`, `.md`, `.rtf`, and `.docx` files in the configured folder without a claim-review step. Do not treat another speaker's work or a meeting action item as the user's contribution. The server parses and sanitizes files; the local runner does not redact file contents.
+
 If manual approval has queued scheduled work, run `pending --harness opencode`, show the complete redacted list, and ask once. After approval, run `approve --approved --harness opencode`.
 
 For an explicit sync-now request:
@@ -14,4 +16,4 @@ For an explicit sync-now request:
 4. In automatic mode, pipe the payload to `sync --harness opencode` without asking again. In manual mode, show the exact payload, ask once, and then use `sync --approved --harness opencode`.
 5. Keep the returned session reference and turn range unchanged. Never upload prompts, raw transcripts, tool output, code, paths, commands, URLs, credentials, names, customer details, or proprietary identifiers.
 
-To connect or finish onboarding, run `connect --harness opencode`. To change the interval or approval policy later, run `config update --harness opencode`.
+To connect or finish onboarding, run `connect --harness opencode`. New connections use one-hour automatic sync and `~/Desktop/Shifu` on macOS by default. To change the interval, approval policy, or folder later, run `config update --harness opencode` with the desired flags (for example, `--input-folder <existing-readable-folder>`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@useshifu/coding-harness",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Scheduled, redacted coding-harness activity sync for Shifu",
   "bin": {
     "coding-harness": "bin/shifu-harness.js",

package/skills/shifu-sync/SKILL.md

@@ -1,13 +1,15 @@
 ---
 name: shifu-sync
-description: Connect, configure, inspect, or sync redacted Codex activity to Shifu, including scheduled and manual-approval modes. Use when the user asks to connect Shifu, change sync settings, inspect pending activity, approve a queued sync, or sync recent harness work.
+description: Connect, configure, inspect, or sync coding-harness activity and local work files to Shifu. Use when the user asks to connect Shifu, change sync settings, inspect pending activity, approve a queued coding sync, or sync recent harness work or input-folder files.
 ---
 
 # Shifu sync
 
 Shifu records useful work completed through the harness. Work may be engineering, product discovery, writing, interview feedback, research, planning, or another user-directed activity. Do not force non-engineering work into engineering categories.
 
-Never upload user prompts, raw transcripts, tool output, source code, commands, credentials, URLs, file paths, names, customer details, or proprietary identifiers. The local runner reads final assistant notes only and enforces redaction and checkpoint rules.
+Never include user prompts, raw transcripts, tool output, source code, commands, credentials, URLs, file paths, names, customer details, or proprietary identifiers in a coding-session payload. The local coding runner reads final assistant notes only and enforces redaction and checkpoint rules. Files placed in the user's chosen Shifu input folder are a separate path: the runner sends supported files over TLS for server-side parsing and sanitization. Do not describe folder files as locally redacted.
+
+Only describe work attributable to the user. A team action item, meeting discussion, or another person's contribution is not evidence that the user did it. If a final note does not support a specific user contribution, do not invent one.
 
 ## Connect or reconfigure
 
@@ -17,20 +19,22 @@ When the user asks to connect, run:
 npx @useshifu/coding-harness connect --harness codex
 ```
 
-`connect` installs the current runner, asks once for the sync interval and approval mode, and installs a local schedule. The defaults are every four hours and automatic approval. If a connection already exists, `connect` keeps its key and checkpoints and completes onboarding only. It also excludes the setup session when the harness exposes its current opaque session reference. No session content is sent during setup.
+`connect` installs the current runner and a local schedule with no policy questions. New connections default to hourly automatic sync and `~/Desktop/Shifu` as the single input folder on macOS. It creates shortcuts at `~/Downloads/Shifu` and `~/Documents/Shifu` when possible without replacing conflicting items. Supported files are `.txt`, `.md`, `.rtf`, and `.docx` directly inside the folder; images and screenshots are not supported. If a connection already exists, `connect` keeps its key, checkpoints, and chosen policy. It also excludes the setup session when the harness exposes its current opaque session reference. No content is sent during setup.
 
-When the user asks to change the interval or approval mode, run:
+When the user asks to change the interval, approval mode, or input folder, run:
 
 ```sh
-npx @useshifu/coding-harness config update --harness codex
+npx @useshifu/coding-harness config update --harness codex --input-folder <existing-readable-folder>
 ```
 
-Do not add a second confirmation around either command. The CLI owns onboarding input.
+Use only the flags the user wants to change; existing settings are preserved. The CLI validates a custom folder before saving. Do not add a second confirmation around either command.
 
 ## Inspect status or queued work
 
 Run `npx @useshifu/coding-harness status --harness codex` to inspect the saved policy, next scheduled run, pending count, and checkpoints.
 
+For an explicit input-folder sync, run `npx @useshifu/coding-harness sync-files --harness codex`. It sends supported files automatically and advances each local checkpoint only after a final server receipt. No claim review or manual approval is needed for files. If a file fails, leave it pending and report the error; do not claim it was synced.
+
 In manual mode, scheduled runs accumulate redacted segments locally. Run:
 
 ```sh