@iowarp/clio-coder 0.3.1 → 0.3.3

package/dist/chunk-FCSXB6T2.js

@@ -0,0 +1,338 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  getEngineEnvApiKey
+} from "./chunk-YXLYO42X.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/engine/ai.ts
+init_esm_shims();
+import {
+  fauxAssistantMessage,
+  calculateCost as piCalculateCost,
+  cleanupSessionResources as piCleanupSessionResources,
+  getSupportedThinkingLevels as piGetSupportedThinkingLevels,
+  isContextOverflow as piIsContextOverflow,
+  isRetryableAssistantError as piIsRetryableAssistantError,
+  validateToolArguments as piValidateToolArguments,
+  StringEnum
+} from "@earendil-works/pi-ai";
+
+// src/engine/api-registry.ts
+init_esm_shims();
+import { anthropicMessagesApi } from "@earendil-works/pi-ai/api/anthropic-messages.lazy";
+import { azureOpenAIResponsesApi } from "@earendil-works/pi-ai/api/azure-openai-responses.lazy";
+import { bedrockConverseStreamApi } from "@earendil-works/pi-ai/api/bedrock-converse-stream.lazy";
+import { googleGenerativeAIApi } from "@earendil-works/pi-ai/api/google-generative-ai.lazy";
+import { googleVertexApi } from "@earendil-works/pi-ai/api/google-vertex.lazy";
+import { mistralConversationsApi } from "@earendil-works/pi-ai/api/mistral-conversations.lazy";
+import { openAICodexResponsesApi } from "@earendil-works/pi-ai/api/openai-codex-responses.lazy";
+import { openAICompletionsApi } from "@earendil-works/pi-ai/api/openai-completions.lazy";
+import { openAIResponsesApi } from "@earendil-works/pi-ai/api/openai-responses.lazy";
+import { piMessagesApi } from "@earendil-works/pi-ai/api/pi-messages.lazy";
+import {
+  createFauxCore
+} from "@earendil-works/pi-ai/providers/faux";
+import "@earendil-works/pi-ai/providers/images/register-builtins";
+
+// src/engine/models.ts
+init_esm_shims();
+import { createModels } from "@earendil-works/pi-ai";
+import { amazonBedrockProvider } from "@earendil-works/pi-ai/providers/amazon-bedrock";
+import { anthropicProvider } from "@earendil-works/pi-ai/providers/anthropic";
+import { deepseekProvider } from "@earendil-works/pi-ai/providers/deepseek";
+import { googleProvider } from "@earendil-works/pi-ai/providers/google";
+import { groqProvider } from "@earendil-works/pi-ai/providers/groq";
+import { mistralProvider } from "@earendil-works/pi-ai/providers/mistral";
+import { openaiProvider } from "@earendil-works/pi-ai/providers/openai";
+import { openaiCodexProvider } from "@earendil-works/pi-ai/providers/openai-codex";
+import { openrouterProvider } from "@earendil-works/pi-ai/providers/openrouter";
+var CONFIGURED_PROVIDER_FACTORIES = [
+  amazonBedrockProvider,
+  anthropicProvider,
+  deepseekProvider,
+  googleProvider,
+  groqProvider,
+  mistralProvider,
+  openaiProvider,
+  openaiCodexProvider,
+  openrouterProvider
+];
+var engineModels = createModels();
+for (const factory of CONFIGURED_PROVIDER_FACTORIES) engineModels.setProvider(factory());
+function engineModelProviders() {
+  return engineModels.getProviders().map((provider) => provider.id);
+}
+function engineModelsFor(provider) {
+  return [...engineModels.getModels(provider)];
+}
+function getEngineModel(provider, modelId) {
+  return engineModels.getModel(provider, modelId);
+}
+
+// src/engine/api-registry.ts
+var registry = /* @__PURE__ */ new Map();
+var builtinInstances = /* @__PURE__ */ new Map();
+var compatUniverse;
+var compatUniversePromise;
+var builtinsRegistered = false;
+function wrappedProvider(provider) {
+  const { api } = provider;
+  return {
+    api,
+    stream(model, context, options) {
+      if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+      return provider.stream(model, context, options);
+    },
+    streamSimple(model, context, options) {
+      if (model.api !== api) throw new Error(`Mismatched api: ${model.api} expected ${api}`);
+      return provider.streamSimple(model, context, options);
+    }
+  };
+}
+function registerEngineApiProvider(provider, sourceId) {
+  const wrapped = wrappedProvider(provider);
+  registry.set(provider.api, { provider: wrapped, ...sourceId === void 0 ? {} : { sourceId } });
+  compatUniverse?.registerApiProvider(provider, sourceId);
+}
+function unregisterEngineApiProviders(sourceId) {
+  for (const [api, entry] of registry) {
+    if (entry.sourceId === sourceId) registry.delete(api);
+  }
+  compatUniverse?.unregisterApiProviders(sourceId);
+}
+function getEngineApiProvider(api) {
+  return registry.get(api)?.provider;
+}
+var BUILTIN_APIS = [
+  ["anthropic-messages", anthropicMessagesApi()],
+  ["openai-completions", openAICompletionsApi()],
+  ["openai-responses", openAIResponsesApi()],
+  ["openai-codex-responses", openAICodexResponsesApi()],
+  ["azure-openai-responses", azureOpenAIResponsesApi()],
+  ["google-generative-ai", googleGenerativeAIApi()],
+  ["google-vertex", googleVertexApi()],
+  ["mistral-conversations", mistralConversationsApi()],
+  ["bedrock-converse-stream", bedrockConverseStreamApi()],
+  ["pi-messages", piMessagesApi()]
+];
+function registerEngineBuiltins() {
+  if (builtinsRegistered) return;
+  builtinsRegistered = true;
+  for (const [api, streams] of BUILTIN_APIS) {
+    if (!getEngineApiProvider(api)) registerEngineApiProvider({ api, ...streams });
+    const registered2 = getEngineApiProvider(api);
+    if (registered2) builtinInstances.set(api, registered2);
+  }
+}
+function withEnvApiKey(model, options) {
+  if (typeof options?.apiKey === "string" && options.apiKey.trim().length > 0) return options;
+  const apiKey = getEngineEnvApiKey(model.provider, options?.env);
+  if (!apiKey || apiKey === "<authenticated>") return options;
+  return { ...options, apiKey };
+}
+function builtinProvider(model) {
+  if (getEngineApiProvider(model.api) !== builtinInstances.get(model.api)) return void 0;
+  const provider = engineModels.getProvider(model.provider);
+  return provider?.getModels().some((candidate) => candidate.api === model.api) ? provider : void 0;
+}
+function resolved(api) {
+  const provider = getEngineApiProvider(api);
+  if (!provider) throw new Error(`No API provider registered for api: ${api}`);
+  return provider;
+}
+function hasCloudflareAuth(options) {
+  return typeof options?.apiKey === "string" && options.apiKey.trim().length > 0 || typeof options?.headers?.["cf-aig-authorization"] === "string";
+}
+function engineStream(model, context, options) {
+  registerEngineBuiltins();
+  if (compatUniverse) return compatUniverse.stream(model, context, options);
+  const provider = builtinProvider(model);
+  if (provider) {
+    if (model.provider.startsWith("cloudflare-") && !hasCloudflareAuth(options)) {
+      return engineModels.stream(model, context, options);
+    }
+    return provider.stream(model, context, withEnvApiKey(model, options));
+  }
+  return resolved(model.api).stream(model, context, withEnvApiKey(model, options));
+}
+function engineStreamSimple(model, context, options) {
+  registerEngineBuiltins();
+  if (compatUniverse) return compatUniverse.streamSimple(model, context, options);
+  const provider = builtinProvider(model);
+  if (provider) {
+    if (model.provider.startsWith("cloudflare-") && !hasCloudflareAuth(options)) {
+      return engineModels.streamSimple(model, context, options);
+    }
+    return provider.streamSimple(model, context, withEnvApiKey(model, options));
+  }
+  return resolved(model.api).streamSimple(model, context, withEnvApiKey(model, options));
+}
+async function completeEngineSimple(model, context, options) {
+  return engineStreamSimple(model, context, options).result();
+}
+function registerEngineFauxProvider(options = {}) {
+  registerEngineBuiltins();
+  const core = createFauxCore(options);
+  const sourceId = `faux-provider-${Math.random().toString(36).slice(2, 10)}`;
+  registerEngineApiProvider({ api: core.api, stream: core.stream, streamSimple: core.streamSimple }, sourceId);
+  return {
+    api: core.api,
+    models: core.models,
+    getModel: core.getModel,
+    state: core.state,
+    setResponses: core.setResponses,
+    appendResponses: core.appendResponses,
+    getPendingResponseCount: core.getPendingResponseCount,
+    unregister() {
+      unregisterEngineApiProviders(sourceId);
+    }
+  };
+}
+async function activateExternalPluginApiBridge() {
+  if (compatUniverse) return;
+  compatUniversePromise ??= (async () => {
+    registerEngineBuiltins();
+    const compat = await import("@earendil-works/pi-ai/compat");
+    for (const [api, entry] of registry) {
+      if (entry.provider === builtinInstances.get(api)) continue;
+      compat.registerApiProvider(entry.provider, entry.sourceId);
+    }
+    compatUniverse = compat;
+  })().catch((error) => {
+    compatUniversePromise = void 0;
+    throw error;
+  });
+  await compatUniversePromise;
+}
+registerEngineBuiltins();
+
+// src/engine/ai.ts
+var stream = engineStream;
+async function completeEngineText(input) {
+  const response = await completeEngineSimple(
+    input.model,
+    {
+      systemPrompt: input.systemPrompt,
+      messages: [{ role: "user", content: input.userPrompt, timestamp: Date.now() }]
+    },
+    {
+      maxTokens: input.maxTokens,
+      signal: input.signal,
+      timeoutMs: input.timeoutMs,
+      ...input.thinkingLevel === "off" ? {} : { reasoning: input.thinkingLevel },
+      ...input.apiKey === void 0 ? {} : { apiKey: input.apiKey }
+    }
+  );
+  if (response.stopReason === "error" || response.stopReason === "aborted") {
+    throw new Error(response.errorMessage ?? `model completion ${response.stopReason}`);
+  }
+  return {
+    text: response.content.filter((block) => block.type === "text").map((block) => block.text).join(""),
+    inputTokens: response.usage.input,
+    outputTokens: response.usage.output
+  };
+}
+var registered = false;
+function ensurePiAiRegistered() {
+  if (registered) return;
+  registerEngineBuiltins();
+  registered = true;
+}
+function createEngineAi() {
+  ensurePiAiRegistered();
+  return {
+    listProviders: () => engineModelProviders(),
+    listModels: (provider) => engineModelsFor(provider),
+    getModel: (provider, modelId) => {
+      try {
+        return getEngineModel(provider, modelId);
+      } catch {
+        return void 0;
+      }
+    }
+  };
+}
+function emptyUsage() {
+  return {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    totalTokens: 0,
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
+  };
+}
+function getEngineSupportedThinkingLevels(model) {
+  return piGetSupportedThinkingLevels(model);
+}
+function cleanupEngineSessionResources(sessionId) {
+  piCleanupSessionResources(sessionId);
+}
+function isEngineContextOverflow(errorMessage, contextWindow) {
+  const message = {
+    role: "assistant",
+    content: [],
+    api: "clio",
+    provider: "clio",
+    model: "unknown",
+    usage: emptyUsage(),
+    stopReason: "error",
+    errorMessage,
+    timestamp: Date.now()
+  };
+  return piIsContextOverflow(message, contextWindow);
+}
+function isEngineRetryableAssistantError(errorMessage) {
+  const message = {
+    role: "assistant",
+    content: [],
+    api: "clio",
+    provider: "clio",
+    model: "unknown",
+    usage: emptyUsage(),
+    stopReason: "error",
+    errorMessage,
+    timestamp: Date.now()
+  };
+  return piIsRetryableAssistantError(message);
+}
+function calculateEngineCost(model, usage) {
+  return piCalculateCost(model, usage);
+}
+function registerFauxFromEnv() {
+  if (process.env.CLIO_CODER_WORKER_FAUX !== "1") return null;
+  const modelId = process.env.CLIO_CODER_WORKER_FAUX_MODEL ?? "faux-model";
+  const text = process.env.CLIO_CODER_WORKER_FAUX_TEXT ?? "ok";
+  const stopReason = process.env.CLIO_CODER_WORKER_FAUX_STOP_REASON ?? "stop";
+  const errorMessage = process.env.CLIO_CODER_WORKER_FAUX_ERROR_MESSAGE;
+  const reg = registerEngineFauxProvider({
+    provider: "faux",
+    models: [{ id: modelId }]
+  });
+  const response = { stopReason };
+  if (errorMessage && errorMessage.length > 0) {
+    response.errorMessage = errorMessage;
+  }
+  reg.setResponses([fauxAssistantMessage(text, response)]);
+  return reg.getModel(modelId);
+}
+
+export {
+  registerEngineApiProvider,
+  engineStreamSimple,
+  activateExternalPluginApiBridge,
+  StringEnum,
+  stream,
+  completeEngineText,
+  ensurePiAiRegistered,
+  createEngineAi,
+  getEngineSupportedThinkingLevels,
+  cleanupEngineSessionResources,
+  isEngineContextOverflow,
+  isEngineRetryableAssistantError,
+  calculateEngineCost,
+  registerFauxFromEnv
+};
+//# sourceMappingURL=chunk-FCSXB6T2.js.map

package/dist/chunk-FJ3H4MN5.js

@@ -0,0 +1,48 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  typebox_exports
+} from "./chunk-5B2AEOW5.js";
+import {
+  ToolNames
+} from "./chunk-CGKSTWHD.js";
+import {
+  StringEnum
+} from "./chunk-FCSXB6T2.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/tools/monitor-surface.ts
+init_esm_shims();
+var monitorToolSurface = {
+  name: ToolNames.Monitor,
+  description: "Inspect known dispatched runs. Parent-model mid-run observation requires detach:true because ordinary dispatch auto-waits. wait observes without collecting. collect is the authoritative terminal batch operation; collect detached runs before final synthesis. receipt exposes stored evidence. Receipt integrity, evidence verification, briefing provenance, and project-context provenance are separate fields.",
+  parameters: typebox_exports.Object({
+    run_id: typebox_exports.Optional(
+      typebox_exports.String({ description: "Run id from dispatch output or monitor list; omit with mode=list." })
+    ),
+    mode: typebox_exports.Optional(
+      StringEnum(["status", "peek", "receipt", "list", "wait", "collect", "tools"], {
+        description: "What to return. Defaults to status when run_id is present and list when it is absent. status, peek, receipt, tools, and wait each observe one run and require a run_id; list takes none. tools answers what a run executed: its tool calls with outcomes, plus per-tool totals from the receipt."
+      })
+    ),
+    batch_id: typebox_exports.Optional(typebox_exports.String({ description: "Detached batch id from dispatch detach:true (mode=collect)." })),
+    run_ids: typebox_exports.Optional(
+      typebox_exports.Array(typebox_exports.String(), {
+        description: "Explicit run ids for mode=collect; a one-element array is also accepted by single-run modes when run_id is absent."
+      })
+    ),
+    timeout_ms: typebox_exports.Optional(
+      typebox_exports.Number({
+        description: "mode=wait: max ms to block (default 60000, capped at 600000); mode=collect never blocks and ignores this value with a notice."
+      })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel"
+};
+
+export {
+  monitorToolSurface
+};
+//# sourceMappingURL=chunk-FJ3H4MN5.js.map

package/dist/{chunk-RPTR2H26.js → chunk-FNTMWMX5.js}

@@ -1,42 +1,48 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   armInternalDispatchDeadline
-} from "./chunk-R5KLMSBV.js";
+} from "./chunk-J5Q24KAG.js";
 import {
   SchedulingDomainModule,
   createPromptsDomainModule
-} from "./chunk-G34LV2PF.js";
+} from "./chunk-LM5TQCJZ.js";
 import {
   AgentsDomainModule,
   SafetyDomainModule
-} from "./chunk-MAR7Y6HW.js";
+} from "./chunk-PAJK6MAQ.js";
 import {
   ConfigDomainModule,
   loadDomains
-} from "./chunk-Q3RUPKEJ.js";
+} from "./chunk-OC7FIQPC.js";
+import {
+  createObservabilityDomainModule
+} from "./chunk-4XUGQOHA.js";
 import {
   fallbackBootstrapOutput
-} from "./chunk-M5T5VO65.js";
+} from "./chunk-PIWWS5BL.js";
 import {
   renderCodewikiDigest
 } from "./chunk-5WIGXA4T.js";
 import {
   DispatchDomainModule,
-  MiddlewareDomainModule,
-  SessionDomainModule,
-  UnsupportedResponseSchemaError,
-  createObservabilityDomainModule,
-  isResponseSchemaRejection
-} from "./chunk-7SS2CTV2.js";
+  SessionDomainModule
+} from "./chunk-SRDMMSEP.js";
 import {
   ResourcesDomainModule
-} from "./chunk-FST4FYJB.js";
+} from "./chunk-MFFY33HR.js";
+import {
+  MiddlewareDomainModule
+} from "./chunk-2DJ2KNFG.js";
+import {
+  UnsupportedResponseSchemaError,
+  isResponseSchemaRejection
+} from "./chunk-LWLEKMDQ.js";
 import {
   parseJsonObjectPayload
-} from "./chunk-GEP36Y4X.js";
+} from "./chunk-STBPMHSX.js";
 import {
   ProvidersDomainModule
-} from "./chunk-H6F6BYOH.js";
+} from "./chunk-LZSJBIVT.js";
 import {
   init_esm_shims
 } from "./chunk-3R73A4XB.js";
@@ -665,4 +671,4 @@ export {
   validateInitOptions,
   bootstrapInputFromInitOptions
 };
-//# sourceMappingURL=chunk-RPTR2H26.js.map
+//# sourceMappingURL=chunk-FNTMWMX5.js.map

package/dist/chunk-FQ4SKYE4.js

@@ -0,0 +1,29 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/core/timers.ts
+init_esm_shims();
+var MAX_TIMER_DELAY_MS = 2147483647;
+function clampTimerDelayMs(value) {
+  if (Number.isNaN(value) || value <= 0) return 0;
+  return value >= MAX_TIMER_DELAY_MS ? MAX_TIMER_DELAY_MS : Math.floor(value);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var negativeDurations = 0;
+function rawDurationMs(start, end) {
+  const elapsed = end - start;
+  if (elapsed < 0) negativeDurations += 1;
+  return elapsed;
+}
+
+export {
+  MAX_TIMER_DELAY_MS,
+  clampTimerDelayMs,
+  sleep,
+  rawDurationMs
+};
+//# sourceMappingURL=chunk-FQ4SKYE4.js.map

package/dist/chunk-G4BMMOKF.js

@@ -0,0 +1,182 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  detectProjectType
+} from "./chunk-YHZX5GEU.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/session/workspace/index.ts
+init_esm_shims();
+
+// src/domains/session/workspace/git-probe.ts
+init_esm_shims();
+import { execFile, execFileSync } from "node:child_process";
+import { promisify } from "node:util";
+var execFileAsync = promisify(execFile);
+var TIMEOUT_MS = 1e3;
+var EMPTY_PROBE = {
+  isGit: false,
+  branch: null,
+  dirty: null,
+  ahead: null,
+  behind: null,
+  recentCommits: [],
+  remoteUrl: null
+};
+var EMPTY_STATUS_PROBE = { isGit: false, branch: null, dirty: null, remoteUrl: null };
+function gitOk(cwd, args) {
+  try {
+    const out = execFileSync("git", args, { cwd, timeout: TIMEOUT_MS, stdio: ["ignore", "pipe", "ignore"] });
+    return out.toString().trim();
+  } catch {
+    return null;
+  }
+}
+async function gitOkAsync(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd, timeout: TIMEOUT_MS, encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return null;
+  }
+}
+function normalizeRemote(url) {
+  let out = url.trim();
+  if (out.endsWith(".git")) out = out.slice(0, -4);
+  const sshMatch = /^git@([^:]+):(.+)$/.exec(out);
+  if (sshMatch) {
+    const [, host, path] = sshMatch;
+    return `https://${host}/${path}`;
+  }
+  return out;
+}
+function branchFrom(raw) {
+  return raw && raw !== "HEAD" ? raw : null;
+}
+function dirtyFrom(status) {
+  return status === null ? null : status.length > 0;
+}
+function aheadBehindFrom(raw) {
+  if (!raw) return { ahead: null, behind: null };
+  const parts = raw.split(/\s+/);
+  const a = Number.parseInt(parts[0] ?? "", 10);
+  const b = Number.parseInt(parts[1] ?? "", 10);
+  return { ahead: Number.isFinite(a) ? a : null, behind: Number.isFinite(b) ? b : null };
+}
+function recentCommitsFrom(log) {
+  if (!log) return [];
+  return log.split("\n").map((line) => {
+    const tab = line.indexOf("	");
+    if (tab < 0) return null;
+    return { sha: line.slice(0, tab), subject: line.slice(tab + 1) };
+  }).filter((commit) => commit !== null);
+}
+function remoteFrom(raw) {
+  return raw ? normalizeRemote(raw) : null;
+}
+function probeGit(cwd) {
+  const inside = gitOk(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") return EMPTY_PROBE;
+  const ignored = gitOk(cwd, ["check-ignore", "--quiet", "--", "."]);
+  if (ignored !== null) return EMPTY_PROBE;
+  const branch = branchFrom(gitOk(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]));
+  const dirty = dirtyFrom(gitOk(cwd, ["status", "--porcelain", "--", "."]));
+  const { ahead, behind } = aheadBehindFrom(gitOk(cwd, ["rev-list", "--left-right", "--count", "HEAD...@{u}"]));
+  const recentCommits = recentCommitsFrom(gitOk(cwd, ["log", "-5", "--format=%H%x09%s", "--", "."]));
+  const remoteUrl = remoteFrom(gitOk(cwd, ["remote", "get-url", "origin"]));
+  return { isGit: true, branch, dirty, ahead, behind, recentCommits, remoteUrl };
+}
+async function probeGitAsync(cwd) {
+  const inside = await gitOkAsync(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") return EMPTY_PROBE;
+  const ignored = await gitOkAsync(cwd, ["check-ignore", "--quiet", "--", "."]);
+  if (ignored !== null) return EMPTY_PROBE;
+  const [branchRaw, status, aheadBehindRaw, log, remoteRaw] = await Promise.all([
+    gitOkAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    gitOkAsync(cwd, ["status", "--porcelain", "--", "."]),
+    gitOkAsync(cwd, ["rev-list", "--left-right", "--count", "HEAD...@{u}"]),
+    gitOkAsync(cwd, ["log", "-5", "--format=%H%x09%s", "--", "."]),
+    gitOkAsync(cwd, ["remote", "get-url", "origin"])
+  ]);
+  const { ahead, behind } = aheadBehindFrom(aheadBehindRaw);
+  return {
+    isGit: true,
+    branch: branchFrom(branchRaw),
+    dirty: dirtyFrom(status),
+    ahead,
+    behind,
+    recentCommits: recentCommitsFrom(log),
+    remoteUrl: remoteFrom(remoteRaw)
+  };
+}
+async function probeGitStatusAsync(cwd) {
+  const inside = await gitOkAsync(cwd, ["rev-parse", "--is-inside-work-tree"]);
+  if (inside !== "true") return EMPTY_STATUS_PROBE;
+  const ignored = await gitOkAsync(cwd, ["check-ignore", "--quiet", "--", "."]);
+  if (ignored !== null) return EMPTY_STATUS_PROBE;
+  const [branchRaw, status, remoteRaw] = await Promise.all([
+    gitOkAsync(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    gitOkAsync(cwd, ["status", "--porcelain", "--", "."]),
+    gitOkAsync(cwd, ["remote", "get-url", "origin"])
+  ]);
+  return {
+    isGit: true,
+    branch: branchFrom(branchRaw),
+    dirty: dirtyFrom(status),
+    remoteUrl: remoteFrom(remoteRaw)
+  };
+}
+
+// src/domains/session/workspace/snapshot.ts
+init_esm_shims();
+function emptyWorkspaceSnapshot(cwd) {
+  return {
+    cwd,
+    isGit: false,
+    branch: null,
+    dirty: null,
+    ahead: null,
+    behind: null,
+    recentCommits: [],
+    remoteUrl: null,
+    projectType: "unknown",
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function snapshotFrom(cwd, git) {
+  let projectType;
+  try {
+    projectType = detectProjectType(cwd);
+  } catch {
+    projectType = "unknown";
+  }
+  return {
+    cwd,
+    isGit: git.isGit,
+    branch: git.branch,
+    dirty: git.dirty,
+    ahead: git.ahead,
+    behind: git.behind,
+    recentCommits: git.recentCommits,
+    remoteUrl: git.remoteUrl,
+    projectType,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+function probeWorkspace(cwd) {
+  return snapshotFrom(cwd, probeGit(cwd));
+}
+async function probeWorkspaceAsync(cwd) {
+  return snapshotFrom(cwd, await probeGitAsync(cwd));
+}
+
+export {
+  probeGit,
+  probeGitAsync,
+  probeGitStatusAsync,
+  emptyWorkspaceSnapshot,
+  probeWorkspace,
+  probeWorkspaceAsync
+};
+//# sourceMappingURL=chunk-G4BMMOKF.js.map