gipity 1.0.355 → 1.0.365

package/dist/hooks/capture-runner.js

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 /**
  * Internal hook runner - invoked by Claude Code's lifecycle hooks
- * (SessionStart, Stop, SubagentStop, SessionEnd) to mirror a terminal
- * `gipity claude` session into the Gipity server so the web CLI can
- * display it read-only.
+ * (SessionStart, Stop, SubagentStop, SessionEnd, and a throttled
+ * PostToolUse for mid-run flushing) to mirror a terminal `gipity claude`
+ * session into the Gipity server so the web CLI can display it read-only.
  *
  * Not a user-facing `gipity` subcommand by design: users never invoke
  * this directly. `setupClaudeHooks` wires up hook entries that call
@@ -12,7 +12,7 @@
  * Usage:
  *   node capture-runner.js <source> <event>
  *   source: 'claude-code' (today) | future: 'codex', …
- *   event:  'session-start' | 'stop' | 'subagent-stop' | 'session-end'
+ *   event:  'session-start' | 'stop' | 'subagent-stop' | 'session-end' | 'post-tool-use'
  *
  * Graceful no-ops (exit 0 silently):
  *   - GIPITY_CONVERSATION_GUID env var unset (hook fired from a bare
@@ -29,6 +29,13 @@ import { deviceFetch } from '../relay/device-http.js';
 import { parseTranscript, } from '../capture/sources/claude-code.js';
 const CAPTURE_DIR = join(homedir(), '.gipity', 'capture-state');
 const INGEST_BATCH_MAX = 100; // server caps at 200; stay comfortably under
+// PostToolUse fires after every tool call. We flush on it so a session that is
+// killed/crashes mid-run (e.g. a long headless `gipity claude -p` build that
+// hits a timeout) still has its transcript in the DB - Stop/SessionEnd only
+// fire on a CLEAN exit, so without this an interrupted run loses EVERYTHING.
+// Throttled to one flush per this interval to bound the cost of re-scanning a
+// growing transcript on every tool call; a kill then loses at most this much tail.
+const POST_TOOL_FLUSH_MS = 10_000;
 function statePath(convGuid) {
     return join(CAPTURE_DIR, `${convGuid}.json`);
 }
@@ -42,7 +49,10 @@ function readState(convGuid) {
     try {
         const raw = readFileSync(p, 'utf-8');
         const parsed = JSON.parse(raw);
-        return { last_uuid: typeof parsed.last_uuid === 'string' ? parsed.last_uuid : null };
+        return {
+            last_uuid: typeof parsed.last_uuid === 'string' ? parsed.last_uuid : null,
+            last_flush_ms: typeof parsed.last_flush_ms === 'number' ? parsed.last_flush_ms : undefined,
+        };
     }
     catch {
         return null;
@@ -143,10 +153,17 @@ async function handleSessionStart(convGuid, hook) {
         }];
     await postEntries(convGuid, entries);
 }
-async function handleStopFamily(convGuid, hook, isSubagent) {
+async function handleStopFamily(convGuid, hook, isSubagent, minIntervalMs = 0) {
     void isSubagent;
     if (!hook.transcript_path || !existsSync(hook.transcript_path))
         return;
+    // Throttle high-frequency callers (PostToolUse). Stop/SessionEnd pass
+    // minIntervalMs=0 so they always flush in full on a clean exit.
+    if (minIntervalMs > 0) {
+        const prev = readState(convGuid);
+        if (prev?.last_flush_ms && Date.now() - prev.last_flush_ms < minIntervalMs)
+            return;
+    }
     const release = acquireLock(convGuid);
     if (!release)
         return; // another hook instance is already flushing; it'll catch our lines
@@ -160,8 +177,10 @@ async function handleStopFamily(convGuid, hook, isSubagent) {
             result = parseTranscript(content, null);
         }
         const ok = await postEntries(convGuid, result.entries);
-        if (ok && result.lastUuid) {
-            writeState(convGuid, { last_uuid: result.lastUuid });
+        if (ok) {
+            // Stamp the flush time even when no new lines landed, so the throttle
+            // above measures from the last attempt. Keep the watermark if unchanged.
+            writeState(convGuid, { last_uuid: result.lastUuid ?? state.last_uuid, last_flush_ms: Date.now() });
         }
     }
     finally {
@@ -218,6 +237,11 @@ async function main() {
             case 'subagent-stop':
                 await handleStopFamily(convGuid, hook, true);
                 break;
+            case 'post-tool-use':
+                // Incremental mid-run flush so an interrupted session keeps its
+                // transcript (Stop/SessionEnd only fire on clean exit). Throttled.
+                await handleStopFamily(convGuid, hook, false, POST_TOOL_FLUSH_MS);
+                break;
             case 'session-end':
                 await handleSessionEnd(convGuid, hook, source);
                 break;

package/dist/index.js

@@ -31,6 +31,7 @@ import { logsCommand } from './commands/logs.js';
 import { pageCommand } from './commands/page.js';
 import { recordsCommand } from './commands/records.js';
 import { fnCommand } from './commands/fn.js';
+import { serviceCommand } from './commands/service.js';
 import { jobCommand } from './commands/job.js';
 import { rbacCommand } from './commands/rbac.js';
 import { auditCommand } from './commands/audit.js';
@@ -47,6 +48,7 @@ import { relayCommand } from './commands/relay.js';
 import { uninstallCommand } from './commands/uninstall.js';
 import { approvalCommand } from './commands/approval.js';
 import { gmailCommand } from './commands/gmail.js';
+import { textCommand } from './commands/text.js';
 import { HELP_SKILL_MAP, fetchAndPrintSkill } from './help-skills.js';
 import { bold, dim, brand, muted, success } from './colors.js';
 import { normalizeAliases } from './flag-aliases.js';
@@ -90,13 +92,19 @@ function configureHelp(cmd) {
     });
 }
 const program = new Command();
+// Global value-options (`--api-base <url>`) are only meaningful before the
+// subcommand. Without this, commander interleaves program + subcommand option
+// parsing and mis-reads a subcommand's `.requiredOption()` as missing when a
+// global value-option precedes it (e.g. `gipity --api-base X workflow create
+// --from Y`). enablePositionalOptions draws the boundary at the first command.
+program.enablePositionalOptions();
 // ── Command groups (logical ordering within each) ──────────────────────
 const commonGroup = [skillCommand, projectCommand, addCommand, deployCommand];
 const connectGroup = [claudeCommand, relayCommand];
 const projectGroup = [domainCommand, statusCommand, initCommand];
 const filesGroup = [fileCommand, syncCommand, pushCommand, uploadCommand];
-const appBuildingGroup = [testCommand, fnCommand, jobCommand, dbCommand, logsCommand, workflowCommand, realtimeCommand, rbacCommand, auditCommand, recordsCommand];
-const utilitiesGroup = [pageCommand, sandboxCommand, generateCommand, emailCommand, gmailCommand, locationCommand];
+const appBuildingGroup = [testCommand, fnCommand, serviceCommand, jobCommand, dbCommand, logsCommand, workflowCommand, realtimeCommand, rbacCommand, auditCommand, recordsCommand];
+const utilitiesGroup = [pageCommand, sandboxCommand, generateCommand, emailCommand, gmailCommand, locationCommand, textCommand];
 const agentGroup = [chatCommand, memoryCommand, agentCommand, approvalCommand];
 const setupGroup = [loginCommand, logoutCommand, creditsCommand, planCommand, doctorCommand, updateCommand, uninstallCommand];
 const HELP_SECTIONS = [
@@ -170,6 +178,27 @@ for (const cmd of HELP_SECTIONS.flatMap(s => s.cmds)) {
     configureHelp(cmd);
     program.addCommand(cmd);
 }
+// ── Malformed invocation → print the error AND the command's help inline ──
+// When an agent guesses the wrong shape (excess args, unknown command/option,
+// missing arg), don't make it run `--help` as a second trip: Commander fires
+// error() on the offending (sub)command, so showHelpAfterError(true) appends
+// that exact command's help, and a labeled header names the canonical help
+// invocation. addCommand doesn't inherit these settings, so apply recursively.
+function fullCommandName(cmd) {
+    const parts = [];
+    for (let c = cmd; c; c = c.parent)
+        parts.unshift(c.name());
+    return parts.join(' ');
+}
+function enableHelpAfterError(cmd) {
+    cmd.showHelpAfterError(true);
+    cmd.configureOutput({
+        outputError: (str, write) => write(`${str.replace(/\n+$/, '')}\n\nShowing \`${fullCommandName(cmd)} --help\`:\n`),
+    });
+    for (const sub of cmd.commands)
+        enableHelpAfterError(sub);
+}
+enableHelpAfterError(program);
 // Auto-fetch related skill docs when --help is run on mapped commands
 const argv = process.argv.slice(2);
 const hasHelp = argv.includes('--help') || argv.includes('-h');

package/dist/knowledge.js

@@ -30,12 +30,13 @@ Kits are reusable building blocks added to an existing app, not whole templates
     - \`gipity add realtime\` - Multiplayer / presence / shared state - channels, host election, server-persisted sync. Engine-agnostic; works in any app.
     - \`gipity add web-vision-mediapipe\` - On-device camera vision - gesture recognition, body pose, object detection. Runs fully client-side via MediaPipe Tasks; no server, no upload. Web only.
     - \`gipity add chatbot\` - Drop-in chatbot - configurable persona, scope guardrails, static knowledge (20k budget), streaming responses. Headless engine + bubble widget; bring your own UI if you want. Works in any app.
-    - \`gipity add audio-align\` - Audio + lyrics -> word-level timing JSON. Demucs vocal isolation + MMS_FA forced alignment, runs as a Modal L4 GPU job (~$0.01 per 3-min song). For karaoke captions, subtitling, language learning, dubbing alignment.`;
+    - \`gipity add audio-align\` - Audio + lyrics -> word-level timing JSON. Demucs vocal isolation + MMS_FA forced alignment, runs as a Modal L4 GPU job (~$0.01 per 3-min song). For karaoke captions, subtitling, language learning, dubbing alignment.
+    - \`gipity add i18n\` - Multi-language for web apps - language picker, locale persistence, RTL, plural/translation lookup. Scaffolds src/js/strings.js and wires it up; move your copy there and read it with t('key'). Web only.`;
 export const SKILLS_CONTENT = `# Gipity Integration
 
 Gipity is the cloud platform your project runs on - hosting, databases, deployment, file storage, code execution, workflows, and monitoring. Gip is the cloud agent that runs on Gipity.
 
-This session is connected to a Gipity project. Prefer the cheapest option that works - CLI and sandbox are instant and free, app services are runtime HTTP calls, \`gipity chat\` burns LLM tokens:
+Prefer the cheapest option that works - CLI and sandbox are instant and free, app services are runtime HTTP calls, \`gipity chat\` burns LLM tokens:
 
 1. CLI commands (fast, no agent overhead). The \`gipity\` CLI covers add, deploy, db, fn, logs, browser, sync, memory, skill, and more. All commands support \`--json\`.
 2. Cloud sandbox via \`gipity sandbox run\` - Docker container with pre-installed tools for media (ffmpeg, ImageMagick, sox), documents (pandoc, LibreOffice), and data (pandas, matplotlib, sqlite3). Run \`gipity skill read sandbox-tools\` for the full toolkit. No network from inside the sandbox - fetch what you need before sending it in.
@@ -46,7 +47,7 @@ You are the developer. Write files in this directory - they auto-sync to Gipity
 
 ## Use first-party services before reaching outside
 
-Gipity ships its own services for things apps usually pull from a third party - auth, location and geocoding, LLM, image/audio/video generation, transcription, file uploads, realtime. Before you call an external API or add an npm package for one of these, run \`gipity skill list\` and look for a matching skill. First-party services need no API keys, cost less, and keep user data off third parties. Reach outside only when the catalog genuinely has no equivalent - and say so when you do.
+Gipity ships first-party services for what apps usually pull from third parties - auth, location/geocoding, LLM, image/audio/video generation, transcription, file uploads, realtime. Before calling an external API or adding an npm package for one of these, check \`gipity skill list\` for a match. First-party services need no API keys, cost less, and keep data in-house. Reach outside only when the catalog has no equivalent - and say so when you do.
 
 ## When to add a template
 
@@ -54,11 +55,19 @@ The full rule and definition of done are injected at the top of every session co
 
 Build loop: \`gipity add\` → edit files → \`gipity deploy dev\` → \`gipity page inspect <url>\` → fix any errors → repeat until the definition of done is met.
 
+Make your file changes and verify they landed, then run \`gipity deploy dev\` once. \`0 uploaded, N unchanged\` means nothing changed on disk - fix the files, don't re-run deploy or probe the environment.
+
+Before telling the user the app is online, verify the source tree is consistent: no files named like \`* (conflict from *)*\`, and every package directory has its expected canonical entry file. If a conflict artifact exists, resolve it (keep one copy), re-deploy, and re-inspect before reporting done.
+
 ## CLI quick reference
 
 Key commands: \`gipity add <template|kit>\`, \`gipity deploy dev\`, \`gipity sandbox run\`, \`gipity page inspect <url>\`, \`gipity db query "SQL"\`, \`gipity fn call <name>\`, \`gipity logs fn <name>\`, \`gipity skill read <name>\`.
 Run \`gipity --help\` for the full list. Use \`--help\` on any command for details.
 
+## Tool output is complete and synchronous
+
+Every tool call returns its full output with that call. There is no output buffer to flush. Never run no-op commands (echo, date, sleep, repeated reads) to "retrieve" or "flush" lagged output - if a result looks empty or delayed, treat it as the actual result and move on, or re-run the real command once.
+
 ## Files and sync
 
 Write files locally - hooks auto-push to Gipity on every save. Remote-generated files (images, audio from \`gipity chat\`) auto-pull. Use \`gipity sync\` if things get out of sync. Deletes are safe - use \`rollback\` with a datetime to undo, or \`file_version_restore\` for individual files.
@@ -85,6 +94,7 @@ App development skills:
 - \`jobs\` - long-running CPU + GPU compute jobs (Python / Node / bash)
 - \`realtime-scheduled-app\` - recipe: realtime presence/messages + DB function + scheduled poster, end-to-end
 - \`web-app-basics\` - coding guidelines, file structure, HTML/CSS/JS patterns
+- \`web-ui-patterns\` - default Gipity look (theme tokens) + web UI recipes - feeds, copy-to-clipboard
 
 Kit skills (reusable building blocks - \`gipity add <kit>\`):
 - \`audio-align\` - the audio-align kit: forced alignment of audio + lyrics into word-level timing JSON

package/dist/relay/daemon.js

@@ -891,15 +891,25 @@ export async function spawnGipityClaude(args, cwd, d) {
         // as they arrive. That's the live-streaming path - every assistant
         // message and tool call appears in the web CLI within a second of
         // Claude emitting it.
+        // Per-dispatch tool_use_id → tool_name map so a `tool_result` event can
+        // be denormalized with its tool's name (the result block omits it).
+        const toolNames = new Map();
         const splitter = createLineSplitter((line) => {
             const evt = parseEvent(line, (reason, snippet) => {
                 log('warn', 'stream-json parse skipped line', { id: d.short_guid, reason, snippet });
             });
             if (!evt)
                 return;
-            const entries = mapEventToEntries(evt);
+            const entries = mapEventToEntries(evt, toolNames);
             if (entries.length === 0)
                 return;
+            // Stamp the read time as the event-time hint (event_at). Stream-json
+            // carries no per-event timestamp; the daemon reads events as Claude
+            // emits them, so receipt time is a close, per-event proxy - far
+            // better than the single flush-time created_at on the whole batch.
+            const ts = new Date().toISOString();
+            for (const e of entries)
+                e.ts = ts;
             // Fire-and-forget POST but tracked so the drain on exit can
             // `allSettled` the set before we claim the spawn is done.
             const p = postIngest(d.conversation_guid, entries)

package/dist/relay/stream-json.js

@@ -62,8 +62,14 @@ function joinAssistantText(content) {
  *  assistant event may yield one `assistant` entry AND one `tool_use`
  *  entry per tool_use block within it (server persists each tool call
  *  as its own `role='tool'` row, then updates it when the matching
- *  `tool_result` arrives). */
-export function mapEventToEntries(evt) {
+ *  `tool_result` arrives).
+ *
+ *  `toolNames` (optional) is a per-dispatch `tool_use_id → tool_name`
+ *  map threaded across events by the daemon: assistant events record
+ *  each tool call's name, the later user event with the paired
+ *  `tool_result` reads it back so the server can denormalize `tool_name`
+ *  onto the tool row even when the result lands as a stub. */
+export function mapEventToEntries(evt, toolNames) {
     const out = [];
     if (evt.type === 'system' && evt.subtype === 'init') {
         const s = evt;
@@ -76,14 +82,16 @@ export function mapEventToEntries(evt) {
         const content = Array.isArray(msg.content) ? msg.content : [];
         const text = joinAssistantText(content);
         if (text || content.length) {
-            out.push({ kind: 'assistant', text, blocks: content });
+            out.push({ kind: 'assistant', text, blocks: content, ...usageFields(msg) });
         }
         for (const block of content) {
             if (block?.type === 'tool_use' && typeof block.id === 'string') {
+                const toolName = typeof block.name === 'string' ? block.name : 'tool';
+                toolNames?.set(block.id, toolName);
                 out.push({
                     kind: 'tool_use',
                     tool_use_id: block.id,
-                    tool_name: typeof block.name === 'string' ? block.name : 'tool',
+                    tool_name: toolName,
                     tool_input: block.input ?? null,
                 });
             }
@@ -98,6 +106,7 @@ export function mapEventToEntries(evt) {
                 out.push({
                     kind: 'tool_result',
                     tool_use_id: block.tool_use_id,
+                    tool_name: toolNames?.get(block.tool_use_id),
                     content: block.content ?? null,
                     is_error: Boolean(block.is_error),
                 });
@@ -105,10 +114,38 @@ export function mapEventToEntries(evt) {
         }
         return out;
     }
-    // `result` is the final footer. The daemon emits its own cosmetic
-    // "Claude Code finished (Xs)" system marker anyway, so this event is
-    // a no-op in the ingest stream. Kept here as a hook-point in case we
-    // want to surface cost/usage later.
+    // `result` is the final footer — a session-level total. Emit a `result`
+    // ingest entry carrying the cost so the server can record it on the
+    // conversation. (Per-turn tokens ride on the assistant entries above; cost is
+    // only ever here, and only on the stream path.)
+    if (evt.type === 'result') {
+        const r = evt;
+        if (typeof r.total_cost_usd === 'number' || typeof r.num_turns === 'number' || typeof r.duration_ms === 'number') {
+            out.push({
+                kind: 'result',
+                total_cost_usd: typeof r.total_cost_usd === 'number' ? r.total_cost_usd : undefined,
+                num_turns: typeof r.num_turns === 'number' ? r.num_turns : undefined,
+                duration_ms: typeof r.duration_ms === 'number' ? r.duration_ms : undefined,
+            });
+        }
+        return out;
+    }
+    return out;
+}
+/** Pull token usage + model + stop_reason off an assistant stream `message`.
+ *  Same shape as the transcript path's `usageFields` (kept in sync; the two
+ *  capture modules don't share a module). Cost is NOT per-message. */
+function usageFields(msg) {
+    const out = {};
+    const u = msg?.usage;
+    if (u && typeof u.input_tokens === 'number')
+        out.input_tokens = u.input_tokens;
+    if (u && typeof u.output_tokens === 'number')
+        out.output_tokens = u.output_tokens;
+    if (typeof msg?.model === 'string')
+        out.model = msg.model;
+    if (typeof msg?.stop_reason === 'string')
+        out.stop_reason = msg.stop_reason;
     return out;
 }
 // ─── Line-buffered stream splitter ─────────────────────────────────────

package/dist/setup.js

@@ -66,6 +66,7 @@ export const PERMISSIONS_SETTINGS = {
             'Bash(gipity file versions *)',
             'Bash(gipity records *)',
             'Bash(gipity fn *)',
+            'Bash(gipity service *)',
             'Bash(gipity rbac *)',
             'Bash(gipity audit *)',
             'Bash(gipity generate *)',
@@ -93,9 +94,11 @@ export function resolveCaptureRunnerPath() {
 //   1. File-sync hooks (PreToolUse / PostToolUse / UserPromptSubmit):
 //      installed unconditionally. Scaffold reminder + push/pull. Not
 //      related to conversation capture.
-//   2. Capture hooks (SessionStart / Stop / SubagentStop / SessionEnd):
-//      mirror a terminal Claude Code session into the Gipity DB so the
-//      web CLI can display it read-only. Toggled by the `captureHooks`
+//   2. Capture hooks (SessionStart / Stop / SubagentStop / SessionEnd, plus
+//      a throttled PostToolUse for mid-run flushing): mirror a terminal
+//      Claude Code session into the Gipity DB so the web CLI can display it
+//      read-only. The PostToolUse capture entry is merged alongside the
+//      file-sync one (see setupClaudeHooks). Toggled by the `captureHooks`
 //      field in `.gipity.json` - default on.
 export const HOOKS_SETTINGS = {
     hooks: {
@@ -153,6 +156,11 @@ function buildCaptureHookEntries(source) {
         Stop: [{ hooks: [{ type: 'command', command: cmd('stop') }] }],
         SubagentStop: [{ hooks: [{ type: 'command', command: cmd('subagent-stop') }] }],
         SessionEnd: [{ hooks: [{ type: 'command', command: cmd('session-end') }] }],
+        // Mid-run incremental flush (matcher '' = every tool). Stop/SessionEnd only
+        // fire on a CLEAN exit, so without this a session that's killed/crashes mid-run
+        // (e.g. a long headless build that times out) loses its whole transcript. The
+        // runner throttles this so it's cheap. Merged alongside the file-sync PostToolUse.
+        PostToolUse: [{ matcher: '', hooks: [{ type: 'command', command: cmd('post-tool-use') }] }],
     };
 }
 export function setupClaudeHooks() {
@@ -173,7 +181,13 @@ export function setupClaudeHooks() {
     // feature for this project without affecting the file-sync hooks.
     const captureEnabled = getConfig()?.captureHooks !== false;
     const captureEntries = captureEnabled ? buildCaptureHookEntries('claude-code') : {};
-    settings.hooks = { ...HOOKS_SETTINGS.hooks, ...captureEntries };
+    // Merge per-event arrays rather than spread-overwriting: capture and file-sync
+    // both register PostToolUse, and a plain spread would drop one of them.
+    const mergedHooks = { ...HOOKS_SETTINGS.hooks };
+    for (const [event, entries] of Object.entries(captureEntries)) {
+        mergedHooks[event] = [...(mergedHooks[event] ?? []), ...entries];
+    }
+    settings.hooks = mergedHooks;
     // Merge permissions (additive - preserve user's existing allows)
     const perms = settings.permissions || {};
     if (!perms.allow)

package/dist/sync.js

@@ -302,8 +302,16 @@ export function plan(local, remote, baseline) {
         // unchanged × unchanged → noop
         if (lSide === 'unchanged' && rSide === 'unchanged')
             continue;
-        // unchanged × modified → download
+        // unchanged × modified → download, but ONLY if the remote genuinely advanced.
+        // Guards a read-after-write race: right after a local write+push, the push can
+        // advance the local baseline to the new version while the remote tree API still
+        // serves the OLD bytes (stale read). That makes remote look "modified" vs an
+        // already-updated baseline, and a blind download would silently clobber the
+        // just-written local file with a stale older version. A real remote change
+        // always carries a strictly newer serverVersion; an equal/older one is stale.
         if (lSide === 'unchanged' && rSide === 'modified') {
+            if (B && R.serverVersion <= B.serverVersion)
+                continue;
             actions.push({ path, kind: 'download', remoteSize: R.size });
             continue;
         }
@@ -359,8 +367,12 @@ export function plan(local, remote, baseline) {
             actions.push({ path, kind: 'delete-remote', remoteSize: R.size, expectedServerVersion: B.serverVersion });
             continue;
         }
-        // deleted × modified → remote wins, restore locally
+        // deleted × modified → remote wins, restore locally — but only if the remote
+        // actually advanced past the baseline. A stale (older/equal) remote read must
+        // not resurrect a file the user intentionally deleted.
         if (lSide === 'deleted' && rSide === 'modified') {
+            if (B && R.serverVersion <= B.serverVersion)
+                continue;
             actions.push({
                 path, kind: 'download', remoteSize: R.size,
                 reason: 'local deleted but remote modified - remote preserved',

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "gipity",
-  "version": "1.0.355",
+  "version": "1.0.365",
   "description": "The full-stack platform tuned for AI agents. Database, storage, auth, functions, deploy, and drop-in kits - all agent-tuned. Pair with Claude Code or use standalone.",
   "bin": {
-    "gipity": "./dist/updater/shim.js",
-    "gipcc": "./dist/gipcc.js",
-    "gipccd": "./dist/gipccd.js"
+    "gipity": "dist/updater/shim.js",
+    "gipcc": "dist/gipcc.js",
+    "gipccd": "dist/gipccd.js"
   },
   "type": "module",
   "scripts": {
     "build": "tsc && chmod +x dist/index.js dist/gipcc.js dist/gipccd.js dist/updater/shim.js dist/updater/check.js",
     "dev": "tsc --watch",
     "test": "npm run test:smoke",
-    "test:smoke": "tsc && node --test dist/__tests__/utils.test.js dist/__tests__/config.test.js dist/__tests__/sync.test.js dist/__tests__/sync-apply.test.js dist/__tests__/sync-lock.test.js dist/__tests__/push-cas.test.js dist/__tests__/upload.test.js dist/__tests__/updater.test.js dist/__tests__/cli-smoke.test.js dist/__tests__/claude-noninteractive.test.js dist/__tests__/claude-trust.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/relay-installers.test.js dist/__tests__/relay-bridge-abort.test.js dist/__tests__/relay-redact.test.js dist/__tests__/relay-machine-id.test.js dist/__tests__/stream-json.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/flag-aliases.test.js dist/__tests__/adopt-cwd.test.js dist/__tests__/cli-cmd-agent.test.js dist/__tests__/cli-cmd-approval.test.js dist/__tests__/cli-cmd-audit.test.js dist/__tests__/cli-cmd-chat.test.js dist/__tests__/cli-cmd-credits.test.js dist/__tests__/cli-cmd-db.test.js dist/__tests__/cli-cmd-deploy.test.js dist/__tests__/cli-cmd-domain.test.js dist/__tests__/cli-cmd-email.test.js dist/__tests__/cli-cmd-file.test.js dist/__tests__/cli-cmd-fn.test.js dist/__tests__/cli-cmd-job.test.js dist/__tests__/cli-cmd-generate.test.js dist/__tests__/cli-cmd-gmail.test.js dist/__tests__/cli-cmd-info.test.js dist/__tests__/cli-cmd-init.test.js dist/__tests__/cli-cmd-location.test.js dist/__tests__/cli-cmd-login.test.js dist/__tests__/cli-cmd-logout.test.js dist/__tests__/cli-cmd-logs.test.js dist/__tests__/cli-cmd-memory.test.js dist/__tests__/cli-cmd-page.test.js dist/__tests__/cli-cmd-plan.test.js dist/__tests__/cli-cmd-project.test.js dist/__tests__/cli-cmd-rbac.test.js dist/__tests__/cli-cmd-realtime.test.js dist/__tests__/cli-cmd-records.test.js dist/__tests__/cli-cmd-relay.test.js dist/__tests__/cli-cmd-sandbox.test.js dist/__tests__/cli-cmd-add.test.js dist/__tests__/cli-cmd-skill.test.js dist/__tests__/cli-cmd-test.test.js dist/__tests__/cli-cmd-workflow.test.js dist/__tests__/setup-skills-block.test.js",
-    "test:e2e": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-live.test.js"
+    "test:smoke": "tsc && node --test dist/__tests__/utils.test.js dist/__tests__/config.test.js dist/__tests__/sync.test.js dist/__tests__/sync-apply.test.js dist/__tests__/sync-lock.test.js dist/__tests__/push-cas.test.js dist/__tests__/upload.test.js dist/__tests__/updater.test.js dist/__tests__/cli-smoke.test.js dist/__tests__/claude-noninteractive.test.js dist/__tests__/claude-trust.test.js dist/__tests__/relay-state.test.js dist/__tests__/relay-daemon.test.js dist/__tests__/relay-installers.test.js dist/__tests__/relay-bridge-abort.test.js dist/__tests__/relay-redact.test.js dist/__tests__/relay-machine-id.test.js dist/__tests__/stream-json.test.js dist/__tests__/relay-ingest-contract.test.js dist/__tests__/prompts.test.js dist/__tests__/capture-transcript.test.js dist/__tests__/flag-aliases.test.js dist/__tests__/adopt-cwd.test.js dist/__tests__/cli-cmd-agent.test.js dist/__tests__/cli-cmd-approval.test.js dist/__tests__/cli-cmd-audit.test.js dist/__tests__/cli-cmd-chat.test.js dist/__tests__/cli-cmd-credits.test.js dist/__tests__/cli-cmd-db.test.js dist/__tests__/cli-cmd-deploy.test.js dist/__tests__/cli-cmd-domain.test.js dist/__tests__/cli-cmd-email.test.js dist/__tests__/cli-cmd-file.test.js dist/__tests__/cli-cmd-fn.test.js dist/__tests__/cli-cmd-service.test.js dist/__tests__/cli-cmd-job.test.js dist/__tests__/cli-cmd-generate.test.js dist/__tests__/cli-cmd-gmail.test.js dist/__tests__/cli-cmd-info.test.js dist/__tests__/cli-cmd-init.test.js dist/__tests__/cli-cmd-location.test.js dist/__tests__/cli-cmd-text.test.js dist/__tests__/cli-cmd-login.test.js dist/__tests__/cli-cmd-logout.test.js dist/__tests__/cli-cmd-logs.test.js dist/__tests__/cli-cmd-memory.test.js dist/__tests__/cli-cmd-page.test.js dist/__tests__/cli-cmd-plan.test.js dist/__tests__/cli-cmd-project.test.js dist/__tests__/cli-cmd-rbac.test.js dist/__tests__/cli-cmd-realtime.test.js dist/__tests__/cli-cmd-records.test.js dist/__tests__/cli-cmd-relay.test.js dist/__tests__/cli-cmd-sandbox.test.js dist/__tests__/cli-cmd-add.test.js dist/__tests__/cli-cmd-skill.test.js dist/__tests__/cli-cmd-test.test.js dist/__tests__/cli-cmd-workflow.test.js dist/__tests__/setup-skills-block.test.js dist/__tests__/setup-hooks.test.js",
+    "test:e2e": "tsc && GIPITY_E2E=1 node --test --test-timeout=180000 dist/__tests__/cli-e2e-live.test.js dist/__tests__/cli-e2e-services-media-live.test.js dist/__tests__/cli-e2e-workflow-live.test.js"
   },
   "dependencies": {
     "commander": "^13.0.0",
@@ -28,7 +28,8 @@
     "node": ">=18"
   },
   "files": [
-    "dist",
+    "dist/**/*.js",
+    "!dist/__tests__/**",
     "hooks"
   ],
   "license": "MIT"

package/dist/__tests__/adopt-cwd.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/__tests__/adopt-cwd.test.js

@@ -1,176 +0,0 @@
-/**
- * Unit tests for the cwd-adoption helpers. Pure logic + small fs walks
- * inside tmp dirs - no network, no real platform state.
- */
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from 'fs';
-import { tmpdir, homedir } from 'os';
-import { join, sep } from 'path';
-import { scanForAdoption, isLikelyEmpty, canAdoptCwd, formatCwdLabel, formatBytes, } from '../adopt-cwd.js';
-let root;
-before(() => {
-    root = mkdtempSync(join(tmpdir(), 'gipity-adopt-test-'));
-});
-after(() => {
-    try {
-        rmSync(root, { recursive: true, force: true });
-    }
-    catch { /* best effort */ }
-});
-function mkdir(p) {
-    const full = join(root, p);
-    mkdirSync(full, { recursive: true });
-    return full;
-}
-function writeBytes(dir, name, n) {
-    writeFileSync(join(dir, name), Buffer.alloc(n));
-}
-describe('scanForAdoption', () => {
-    it('returns easy tier for a tiny project', () => {
-        const d = mkdir('easy');
-        writeBytes(d, 'a.txt', 10);
-        writeBytes(d, 'b.txt', 10);
-        const s = scanForAdoption(d);
-        assert.equal(s.tier, 'easy');
-        assert.equal(s.files, 2);
-        assert.equal(s.bytes, 20);
-        assert.equal(s.truncated, false);
-    });
-    it('handles a missing directory gracefully', () => {
-        const s = scanForAdoption(join(root, 'no-such-dir'));
-        assert.equal(s.tier, 'easy');
-        assert.equal(s.files, 0);
-    });
-    it('walks nested directories', () => {
-        const d = mkdir('nested');
-        const sub = mkdir('nested/sub/sub2');
-        writeBytes(d, 'top.txt', 1);
-        writeBytes(sub, 'deep.txt', 2);
-        const s = scanForAdoption(d);
-        assert.equal(s.files, 2);
-        assert.equal(s.bytes, 3);
-    });
-    it('returns moderate tier when over the easy file-count threshold', () => {
-        const d = mkdir('moderate-files');
-        for (let i = 0; i < 250; i++)
-            writeBytes(d, `f${i}.txt`, 1);
-        const s = scanForAdoption(d);
-        assert.equal(s.tier, 'moderate');
-        assert.equal(s.truncated, false);
-    });
-    it('returns refuse + truncated when over the refuse file-count threshold', () => {
-        const d = mkdir('refuse-files');
-        for (let i = 0; i < 2100; i++)
-            writeBytes(d, `f${i}.txt`, 1);
-        const s = scanForAdoption(d);
-        assert.equal(s.tier, 'refuse');
-        assert.equal(s.truncated, true);
-    });
-    it('skips sync-ignored entries (node_modules, .git)', () => {
-        const d = mkdir('with-junk');
-        writeBytes(d, 'real.txt', 1);
-        const nm = mkdir('with-junk/node_modules');
-        writeBytes(nm, 'should-not-count.txt', 999_999);
-        const git = mkdir('with-junk/.git');
-        writeBytes(git, 'also-skip.txt', 999_999);
-        const s = scanForAdoption(d);
-        assert.equal(s.files, 1);
-        assert.equal(s.bytes, 1);
-    });
-});
-describe('isLikelyEmpty', () => {
-    it('true for a truly empty dir', () => {
-        const d = mkdir('empty');
-        assert.equal(isLikelyEmpty(d), true);
-    });
-    it('true for a dir with only sync-ignored entries', () => {
-        const d = mkdir('only-junk');
-        mkdir('only-junk/node_modules');
-        mkdir('only-junk/.git');
-        assert.equal(isLikelyEmpty(d), true);
-    });
-    it('false when there is any real file', () => {
-        const d = mkdir('not-empty');
-        writeBytes(d, 'hello.md', 1);
-        assert.equal(isLikelyEmpty(d), false);
-    });
-    it('true when the dir does not exist', () => {
-        assert.equal(isLikelyEmpty(join(root, 'ghost')), true);
-    });
-});
-describe('canAdoptCwd', () => {
-    it('refuses the filesystem root', () => {
-        assert.equal(canAdoptCwd(sep), false);
-    });
-    it('refuses the user\'s home directory', () => {
-        assert.equal(canAdoptCwd(homedir()), false);
-    });
-    it('refuses system dirs', () => {
-        assert.equal(canAdoptCwd('/tmp'), false);
-        assert.equal(canAdoptCwd('/etc'), false);
-        assert.equal(canAdoptCwd('/usr'), false);
-    });
-    it('allows a subdirectory of /tmp', () => {
-        const d = mkdir('allowed-subdir');
-        assert.equal(canAdoptCwd(d), true);
-    });
-    it('refuses a workspace-parent (depth ≤1 below home with 3+ git children)', () => {
-        // Simulate ~/Workspace/{a,b,c}/.git
-        const ws = mkdtempSync(join(homedir(), 'gipity-adopt-ws-'));
-        try {
-            for (const sub of ['a', 'b', 'c']) {
-                mkdirSync(join(ws, sub, '.git'), { recursive: true });
-            }
-            assert.equal(canAdoptCwd(ws), false);
-        }
-        finally {
-            rmSync(ws, { recursive: true, force: true });
-        }
-    });
-    it('allows a single-project dir even at depth ≤1 under home', () => {
-        const single = mkdtempSync(join(homedir(), 'gipity-adopt-single-'));
-        try {
-            mkdirSync(join(single, '.git'), { recursive: true });
-            assert.equal(canAdoptCwd(single), true);
-        }
-        finally {
-            rmSync(single, { recursive: true, force: true });
-        }
-    });
-});
-describe('formatCwdLabel', () => {
-    it('returns "~" for the home dir', () => {
-        assert.equal(formatCwdLabel(homedir()), '~');
-    });
-    it('uses ~/tail when 1-2 segments deep in home', () => {
-        assert.equal(formatCwdLabel(join(homedir(), 'Github')), '~/Github');
-        assert.equal(formatCwdLabel(join(homedir(), 'Github', 'Gipity')), '~/Github/Gipity');
-    });
-    it('uses ~/…/last-2 when deeper in home', () => {
-        const deep = join(homedir(), 'a', 'b', 'c', 'd');
-        assert.equal(formatCwdLabel(deep), '~/…/c/d');
-    });
-    it('shows parent/this for non-home paths', () => {
-        assert.equal(formatCwdLabel('/tmp/scratch'), 'tmp/scratch');
-    });
-});
-describe('formatBytes', () => {
-    it('B for sub-KB', () => {
-        assert.equal(formatBytes(0), '0 B');
-        assert.equal(formatBytes(512), '512 B');
-    });
-    it('KB for sub-MB', () => {
-        assert.equal(formatBytes(1024), '1.0 KB');
-        assert.equal(formatBytes(2048), '2.0 KB');
-    });
-    it('MB for sub-GB', () => {
-        assert.equal(formatBytes(1024 * 1024), '1.0 MB');
-        assert.equal(formatBytes(50 * 1024 * 1024), '50.0 MB');
-    });
-    it('GB for ≥ GB (fixes the "1024.0 MB" overflow at the refuse threshold)', () => {
-        assert.equal(formatBytes(1024 * 1024 * 1024), '1.00 GB');
-        assert.equal(formatBytes(2.5 * 1024 * 1024 * 1024), '2.50 GB');
-    });
-});
-//# sourceMappingURL=adopt-cwd.test.js.map