t3code-cli 0.2.0 → 0.3.0

package/dist/upstream-t3code/packages/contracts/src/terminal.d.ts

@@ -0,0 +1,330 @@
+import * as Schema from "effect/Schema";
+/**
+ * Client-side id for the first shell opened on a thread. Ids are uniformly
+ * `term-N`; there's no "default" intrinsic. Kept as a named constant so callers
+ * that want "the primary shell" don't hardcode `"term-1"`.
+ */
+export declare const DEFAULT_TERMINAL_ID = "term-1";
+export declare const TerminalThreadInput: Schema.Struct<{
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalThreadInput = typeof TerminalThreadInput.Type;
+/** Terminal ids are ALWAYS chosen by the client and sent explicitly — no server-side allocation. */
+declare const TerminalSessionInput: Schema.Struct<{
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalSessionInput = Schema.Codec.Encoded<typeof TerminalSessionInput>;
+export declare const TerminalOpenInput: Schema.Struct<{
+    readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly worktreePath: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>>;
+    readonly cols: Schema.optional<Schema.Int>;
+    readonly rows: Schema.optional<Schema.Int>;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalOpenInput = Schema.Codec.Encoded<typeof TerminalOpenInput>;
+export declare const TerminalAttachInput: Schema.Struct<{
+    readonly cwd: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly worktreePath: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>>;
+    readonly cols: Schema.optional<Schema.Int>;
+    readonly rows: Schema.optional<Schema.Int>;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly restartIfNotRunning: Schema.optional<Schema.Boolean>;
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalAttachInput = Schema.Codec.Encoded<typeof TerminalAttachInput>;
+export declare const TerminalWriteInput: Schema.Struct<{
+    readonly data: Schema.String;
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalWriteInput = Schema.Codec.Encoded<typeof TerminalWriteInput>;
+export declare const TerminalResizeInput: Schema.Struct<{
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalResizeInput = Schema.Codec.Encoded<typeof TerminalResizeInput>;
+export declare const TerminalClearInput: Schema.Struct<{
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalClearInput = Schema.Codec.Encoded<typeof TerminalClearInput>;
+export declare const TerminalRestartInput: Schema.Struct<{
+    readonly cwd: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly worktreePath: Schema.optional<Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>>;
+    readonly cols: Schema.Int;
+    readonly rows: Schema.Int;
+    readonly env: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+    readonly terminalId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalRestartInput = Schema.Codec.Encoded<typeof TerminalRestartInput>;
+export declare const TerminalCloseInput: Schema.Struct<{
+    readonly terminalId: Schema.optional<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly deleteHistory: Schema.optional<Schema.Boolean>;
+    readonly threadId: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+}>;
+export type TerminalCloseInput = typeof TerminalCloseInput.Type;
+export declare const TerminalSessionStatus: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+export type TerminalSessionStatus = typeof TerminalSessionStatus.Type;
+export declare const TerminalSessionSnapshot: Schema.Struct<{
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cwd: Schema.String;
+    readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly history: Schema.String;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.Int>;
+    /** Server-computed display title (idle shell vs subprocess command). */
+    readonly label: Schema.String;
+    readonly updatedAt: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>;
+export type TerminalSessionSnapshot = typeof TerminalSessionSnapshot.Type;
+export declare const TerminalSummary: Schema.Struct<{
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cwd: Schema.String;
+    readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+    readonly pid: Schema.NullOr<Schema.Int>;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.Int>;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    /** Server-computed display title (idle shell vs subprocess command). */
+    readonly label: Schema.String;
+    readonly updatedAt: Schema.String;
+}>;
+export type TerminalSummary = typeof TerminalSummary.Type;
+export declare const TerminalMetadataStreamEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"snapshot">;
+    readonly terminals: Schema.$Array<Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        readonly hasRunningSubprocess: Schema.Boolean;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"upsert">;
+    readonly terminal: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        readonly hasRunningSubprocess: Schema.Boolean;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"remove">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+}>]>;
+export type TerminalMetadataStreamEvent = typeof TerminalMetadataStreamEvent.Type;
+export declare const TerminalEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"started">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly sequence: Schema.optional<Schema.Int>;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly data: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exited">;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.Int>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"closed">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cleared">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"restarted">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly sequence: Schema.optional<Schema.Int>;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"activity">;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    readonly label: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>]>;
+export type TerminalEvent = typeof TerminalEvent.Type;
+export declare const TerminalAttachStreamEvent: Schema.Union<readonly [Schema.Struct<{
+    readonly type: Schema.Literal<"snapshot">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly sequence: Schema.optional<Schema.Int>;
+    }>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"output">;
+    readonly data: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"exited">;
+    readonly exitCode: Schema.NullOr<Schema.Int>;
+    readonly exitSignal: Schema.NullOr<Schema.Int>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"closed">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"error">;
+    readonly message: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"cleared">;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"restarted">;
+    readonly snapshot: Schema.Struct<{
+        readonly threadId: Schema.String;
+        readonly terminalId: Schema.String;
+        readonly cwd: Schema.String;
+        readonly worktreePath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly status: Schema.Literals<readonly ["starting", "running", "exited", "error"]>;
+        readonly pid: Schema.NullOr<Schema.Int>;
+        readonly history: Schema.String;
+        readonly exitCode: Schema.NullOr<Schema.Int>;
+        readonly exitSignal: Schema.NullOr<Schema.Int>;
+        /** Server-computed display title (idle shell vs subprocess command). */
+        readonly label: Schema.String;
+        readonly updatedAt: Schema.String;
+        readonly sequence: Schema.optional<Schema.Int>;
+    }>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>, Schema.Struct<{
+    readonly type: Schema.Literal<"activity">;
+    readonly hasRunningSubprocess: Schema.Boolean;
+    readonly label: Schema.String;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly sequence: Schema.optional<Schema.Int>;
+}>]>;
+export type TerminalAttachStreamEvent = typeof TerminalAttachStreamEvent.Type;
+declare const TerminalCwdError_base: Schema.Class<TerminalCwdError, Schema.TaggedStruct<"TerminalCwdError", {
+    readonly cwd: Schema.String;
+    readonly reason: Schema.Literals<readonly ["notFound", "notDirectory", "statFailed"]>;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class TerminalCwdError extends TerminalCwdError_base {
+    get message(): string;
+}
+declare const TerminalHistoryError_base: Schema.Class<TerminalHistoryError, Schema.TaggedStruct<"TerminalHistoryError", {
+    readonly operation: Schema.Literals<readonly ["read", "truncate", "migrate"]>;
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class TerminalHistoryError extends TerminalHistoryError_base {
+    get message(): string;
+}
+declare const TerminalSessionLookupError_base: Schema.Class<TerminalSessionLookupError, Schema.TaggedStruct<"TerminalSessionLookupError", {
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class TerminalSessionLookupError extends TerminalSessionLookupError_base {
+    get message(): string;
+}
+declare const TerminalNotRunningError_base: Schema.Class<TerminalNotRunningError, Schema.TaggedStruct<"TerminalNotRunningError", {
+    readonly threadId: Schema.String;
+    readonly terminalId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class TerminalNotRunningError extends TerminalNotRunningError_base {
+    get message(): string;
+}
+export declare const TerminalError: Schema.Union<readonly [typeof TerminalCwdError, typeof TerminalHistoryError, typeof TerminalSessionLookupError, typeof TerminalNotRunningError]>;
+export type TerminalError = typeof TerminalError.Type;
+export {};

package/dist/upstream-t3code/packages/contracts/src/vcs.d.ts

@@ -0,0 +1,148 @@
+import * as Schema from "effect/Schema";
+export declare const VcsDriverKind: Schema.Literals<readonly ["git", "jj", "unknown"]>;
+export type VcsDriverKind = typeof VcsDriverKind.Type;
+export declare const VcsFreshnessSource: Schema.Literals<readonly ["live-local", "cached-local", "cached-remote", "explicit-remote"]>;
+export type VcsFreshnessSource = typeof VcsFreshnessSource.Type;
+export declare const VcsFreshness: Schema.Struct<{
+    readonly source: Schema.Literals<readonly ["live-local", "cached-local", "cached-remote", "explicit-remote"]>;
+    readonly observedAt: Schema.DateTimeUtc;
+    readonly expiresAt: Schema.Option<Schema.DateTimeUtc>;
+}>;
+export type VcsFreshness = typeof VcsFreshness.Type;
+export declare const VcsDriverCapabilities: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["git", "jj", "unknown"]>;
+    readonly supportsWorktrees: Schema.Boolean;
+    readonly supportsBookmarks: Schema.Boolean;
+    readonly supportsAtomicSnapshot: Schema.Boolean;
+    readonly supportsPushDefaultRemote: Schema.Boolean;
+    readonly ignoreClassifier: Schema.Literals<readonly ["native", "git-compatible-fallback"]>;
+}>;
+export type VcsDriverCapabilities = typeof VcsDriverCapabilities.Type;
+export declare const VcsRepositoryIdentity: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["git", "jj", "unknown"]>;
+    readonly rootPath: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly metadataPath: Schema.NullOr<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly freshness: Schema.Struct<{
+        readonly source: Schema.Literals<readonly ["live-local", "cached-local", "cached-remote", "explicit-remote"]>;
+        readonly observedAt: Schema.DateTimeUtc;
+        readonly expiresAt: Schema.Option<Schema.DateTimeUtc>;
+    }>;
+}>;
+export type VcsRepositoryIdentity = typeof VcsRepositoryIdentity.Type;
+export declare const VcsListWorkspaceFilesResult: Schema.Struct<{
+    readonly paths: Schema.$Array<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly truncated: Schema.Boolean;
+    readonly freshness: Schema.Struct<{
+        readonly source: Schema.Literals<readonly ["live-local", "cached-local", "cached-remote", "explicit-remote"]>;
+        readonly observedAt: Schema.DateTimeUtc;
+        readonly expiresAt: Schema.Option<Schema.DateTimeUtc>;
+    }>;
+}>;
+export type VcsListWorkspaceFilesResult = typeof VcsListWorkspaceFilesResult.Type;
+export declare const VcsRemote: Schema.Struct<{
+    readonly name: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly url: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+    readonly pushUrl: Schema.Option<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+    readonly isPrimary: Schema.Boolean;
+}>;
+export type VcsRemote = typeof VcsRemote.Type;
+export declare const VcsListRemotesResult: Schema.Struct<{
+    readonly remotes: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+        readonly url: Schema.decodeTo<Schema.String, Schema.String, never, never>;
+        readonly pushUrl: Schema.Option<Schema.decodeTo<Schema.String, Schema.String, never, never>>;
+        readonly isPrimary: Schema.Boolean;
+    }>>;
+    readonly freshness: Schema.Struct<{
+        readonly source: Schema.Literals<readonly ["live-local", "cached-local", "cached-remote", "explicit-remote"]>;
+        readonly observedAt: Schema.DateTimeUtc;
+        readonly expiresAt: Schema.Option<Schema.DateTimeUtc>;
+    }>;
+}>;
+export type VcsListRemotesResult = typeof VcsListRemotesResult.Type;
+export interface VcsProcessErrorContext {
+    readonly operation: string;
+    readonly command: string;
+    readonly cwd: string;
+}
+export interface VcsProcessSpawnFailure {
+    readonly cause: unknown;
+}
+export interface VcsProcessStdinFailure {
+    readonly cause: unknown;
+}
+export interface VcsProcessReadFailure {
+    readonly stream: "stdout" | "stderr" | "exitCode";
+    readonly cause: unknown;
+}
+export interface VcsProcessOutputLimitFailure {
+    readonly stream: "stdout" | "stderr";
+    readonly maxBytes: number;
+}
+export interface VcsProcessTimeoutFailure {
+    readonly timeoutMs: number;
+}
+declare const VcsProcessSpawnError_base: Schema.Class<VcsProcessSpawnError, Schema.TaggedStruct<"VcsProcessSpawnError", {
+    readonly operation: Schema.String;
+    readonly command: Schema.String;
+    readonly cwd: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsProcessSpawnError extends VcsProcessSpawnError_base {
+    get message(): string;
+    static fromProcessSpawnError(context: VcsProcessErrorContext, error: VcsProcessSpawnFailure): VcsProcessSpawnError;
+}
+declare const VcsProcessExitError_base: Schema.Class<VcsProcessExitError, Schema.TaggedStruct<"VcsProcessExitError", {
+    readonly operation: Schema.String;
+    readonly command: Schema.String;
+    readonly cwd: Schema.String;
+    readonly exitCode: Schema.Number;
+    readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsProcessExitError extends VcsProcessExitError_base {
+    get message(): string;
+}
+declare const VcsProcessTimeoutError_base: Schema.Class<VcsProcessTimeoutError, Schema.TaggedStruct<"VcsProcessTimeoutError", {
+    readonly operation: Schema.String;
+    readonly command: Schema.String;
+    readonly cwd: Schema.String;
+    readonly timeoutMs: Schema.Number;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsProcessTimeoutError extends VcsProcessTimeoutError_base {
+    get message(): string;
+    static fromProcessTimeoutError(context: VcsProcessErrorContext, error: VcsProcessTimeoutFailure): VcsProcessTimeoutError;
+}
+declare const VcsOutputDecodeError_base: Schema.Class<VcsOutputDecodeError, Schema.TaggedStruct<"VcsOutputDecodeError", {
+    readonly operation: Schema.String;
+    readonly command: Schema.String;
+    readonly cwd: Schema.String;
+    readonly detail: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsOutputDecodeError extends VcsOutputDecodeError_base {
+    get message(): string;
+    static fromProcessStdinError(context: VcsProcessErrorContext, error: VcsProcessStdinFailure): VcsOutputDecodeError;
+    static fromProcessReadError(context: VcsProcessErrorContext, error: VcsProcessReadFailure): VcsOutputDecodeError;
+    static fromProcessOutputLimitError(context: VcsProcessErrorContext, error: VcsProcessOutputLimitFailure): VcsOutputDecodeError;
+    static missingExitCode(context: VcsProcessErrorContext): VcsOutputDecodeError;
+}
+declare const VcsRepositoryDetectionError_base: Schema.Class<VcsRepositoryDetectionError, Schema.TaggedStruct<"VcsRepositoryDetectionError", {
+    readonly operation: Schema.String;
+    readonly cwd: Schema.String;
+    readonly detail: Schema.String;
+    readonly cause: Schema.optional<Schema.Defect>;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsRepositoryDetectionError extends VcsRepositoryDetectionError_base {
+    get message(): string;
+}
+declare const VcsUnsupportedOperationError_base: Schema.Class<VcsUnsupportedOperationError, Schema.TaggedStruct<"VcsUnsupportedOperationError", {
+    readonly operation: Schema.String;
+    readonly kind: Schema.Literals<readonly ["git", "jj", "unknown"]>;
+    readonly detail: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class VcsUnsupportedOperationError extends VcsUnsupportedOperationError_base {
+    get message(): string;
+}
+export declare const VcsError: Schema.Union<readonly [typeof VcsProcessSpawnError, typeof VcsProcessExitError, typeof VcsProcessTimeoutError, typeof VcsOutputDecodeError, typeof VcsRepositoryDetectionError, typeof VcsUnsupportedOperationError]>;
+export type VcsError = typeof VcsError.Type;
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "t3code-cli",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "CLI for t3code",
   "keywords": [
     "claude",
@@ -26,18 +26,26 @@
     "src"
   ],
   "type": "module",
+  "types": "./dist/src/index.d.ts",
+  "imports": {
+    "#t3tools/contracts": {
+      "types": "./dist/upstream-t3code/packages/contracts/src/index.d.ts",
+      "default": "./dist/upstream-t3code/packages/contracts/src/index.d.ts"
+    }
+  },
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./src/index.ts"
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/index.js"
     }
   },
-  "dependencies": {},
+  "dependencies": {
+    "@effect/platform-node": "4.0.0-beta.74",
+    "effect": "4.0.0-beta.74"
+  },
   "devDependencies": {
     "@changesets/cli": "^2.31.0",
-    "@effect/platform-node": "4.0.0-beta.74",
     "@types/node": "^25.9.1",
-    "effect": "4.0.0-beta.74",
     "typescript": "^6.0.3",
     "vite-plus": "^0.1.24",
     "@t3tools/contracts": "0.0.24"
@@ -46,7 +54,7 @@
     "node": "^24.0.0"
   },
   "scripts": {
-    "build": "vp pack",
+    "build": "vp pack && tsc -p tsconfig.dts.json",
     "check": "vp check",
     "format": "vp fmt",
     "format:check": "vp fmt --check",

package/src/application/model-selection.ts

@@ -1,6 +1,6 @@
 import * as Effect from "effect/Effect";
-import { ModelSelection, ProviderInstanceId } from "@t3tools/contracts";
-import type { OrchestrationProjectShell } from "@t3tools/contracts";
+import { ModelSelection, ProviderInstanceId } from "#t3tools/contracts";
+import type { OrchestrationProjectShell } from "#t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 import { ModelSelectionError } from "../domain/error.ts";

package/src/application/project-commands.ts

@@ -2,7 +2,7 @@ import * as Crypto from "effect/Crypto";
 import * as DateTime from "effect/DateTime";
 import * as Effect from "effect/Effect";
 import * as Path from "effect/Path";
-import { CommandId, ProjectId, type ClientOrchestrationCommand } from "@t3tools/contracts";
+import { CommandId, ProjectId, type ClientOrchestrationCommand } from "#t3tools/contracts";
 
 import { Environment } from "../environment/service.ts";
 

package/src/application/service.ts

@@ -10,7 +10,7 @@ import type {
   OrchestrationThread,
   OrchestrationThreadShell,
   ServerProvider,
-} from "@t3tools/contracts";
+} from "#t3tools/contracts";
 
 import type { ApplicationError } from "./error.ts";
 

package/src/application/shell-sequence.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import { ORCHESTRATION_WS_METHODS } from "@t3tools/contracts";
+import { ORCHESTRATION_WS_METHODS } from "#t3tools/contracts";
 
 import type { Orchestration } from "../orchestration/service.ts";
 import { RpcError } from "../rpc/error.ts";

package/src/application/thread-commands.ts

@@ -8,7 +8,7 @@ import {
   type ClientOrchestrationCommand,
   type ModelSelection,
   type OrchestrationProjectShell,
-} from "@t3tools/contracts";
+} from "#t3tools/contracts";
 import type { ServerConfigForCli } from "../orchestration/service.ts";
 import { resolveModelSelection } from "./model-selection.ts";
 import type { SendThreadInput, StartThreadInput } from "./service.ts";

package/src/application/thread-wait.ts

@@ -1,7 +1,7 @@
 import * as Effect from "effect/Effect";
 import * as Option from "effect/Option";
 import * as Stream from "effect/Stream";
-import type { OrchestrationMessage, OrchestrationThread } from "@t3tools/contracts";
+import type { OrchestrationMessage, OrchestrationThread } from "#t3tools/contracts";
 
 import { ThreadSessionError } from "../domain/error.ts";
 import type { Orchestration } from "../orchestration/service.ts";

package/src/cli/model-format.ts

@@ -1,4 +1,4 @@
-import type { ServerProvider } from "@t3tools/contracts";
+import type { ServerProvider } from "#t3tools/contracts";
 
 export function formatModelsHuman(providers: ReadonlyArray<ServerProvider>) {
   if (providers.length === 0) {

package/src/cli/project-format.ts

@@ -1,4 +1,4 @@
-import type { OrchestrationProjectShell } from "@t3tools/contracts";
+import type { OrchestrationProjectShell } from "#t3tools/contracts";
 
 export function formatProjectsHuman(projects: ReadonlyArray<OrchestrationProjectShell>) {
   return projects

package/src/cli/thread-format.ts

@@ -1,5 +1,5 @@
 import type { WaitEvent } from "../application/service.ts";
-import type { OrchestrationThread, OrchestrationThreadShell } from "@t3tools/contracts";
+import type { OrchestrationThread, OrchestrationThreadShell } from "#t3tools/contracts";
 import { latestAssistantMessage, threadStatus } from "../domain/thread-lifecycle.ts";
 
 export function formatThreadsHuman(threads: ReadonlyArray<OrchestrationThreadShell>) {

package/src/domain/helpers.ts

@@ -1,5 +1,5 @@
 import type * as Path from "effect/Path";
-import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "@t3tools/contracts";
+import type { OrchestrationProjectShell, OrchestrationShellSnapshot } from "#t3tools/contracts";
 
 import { ProjectLookupError } from "./error.ts";
 

package/src/domain/model-config.ts

@@ -1,4 +1,4 @@
-import type { ServerProvider } from "@t3tools/contracts";
+import type { ServerProvider } from "#t3tools/contracts";
 
 export function isSelectableProvider(provider: ServerProvider) {
   return provider.status === "ready" && provider.models.length > 0;

package/src/domain/thread-lifecycle.ts

@@ -4,7 +4,7 @@ import {
   type OrchestrationMessage as OrchestrationMessageType,
   type OrchestrationThread,
   type OrchestrationThreadShell,
-} from "@t3tools/contracts";
+} from "#t3tools/contracts";
 import * as Schema from "effect/Schema";
 
 export function isThreadActive(thread: OrchestrationThreadShell | OrchestrationThread) {

package/src/index.ts

@@ -6,6 +6,8 @@ export type {
   WaitEvent,
 } from "./application/service.ts";
 export type { ApplicationError } from "./application/error.ts";
+export { NodeEnvironmentLive } from "./environment/layer.ts";
+export { AppLayer, AuthAppLayer } from "./runtime.ts";
 export type {
   OrchestrationMessage,
   OrchestrationProjectShell,
@@ -13,6 +15,4 @@ export type {
   OrchestrationThread,
   OrchestrationThreadShell,
   ServerProvider,
-} from "@t3tools/contracts";
-export { NodeEnvironmentLive } from "./environment/layer.ts";
-export { AppLayer, AuthAppLayer } from "./runtime.ts";
+} from "#t3tools/contracts";