@prover-coder-ai/docker-git 1.0.8 → 1.0.10

package/dist/src/docker-git/cli/parser-options.js

@@ -16,6 +16,8 @@ const valueOptionSpecs = [
     { flag: "--env-project", key: "envProjectPath" },
     { flag: "--codex-auth", key: "codexAuthPath" },
     { flag: "--codex-home", key: "codexHome" },
+    { flag: "--archive", key: "archivePath" },
+    { flag: "--mode", key: "scrapMode" },
     { flag: "--label", key: "label" },
     { flag: "--token", key: "token" },
     { flag: "--scopes", key: "scopes" },
@@ -33,6 +35,8 @@ const booleanFlagUpdaters = {
     "--force-env": (raw) => ({ ...raw, forceEnv: true }),
     "--mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: true }),
     "--no-mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: false }),
+    "--wipe": (raw) => ({ ...raw, wipe: true }),
+    "--no-wipe": (raw) => ({ ...raw, wipe: false }),
     "--web": (raw) => ({ ...raw, authWeb: true }),
     "--include-default": (raw) => ({ ...raw, includeDefault: true })
 };
@@ -51,6 +55,8 @@ const valueFlagUpdaters = {
     envProjectPath: (raw, value) => ({ ...raw, envProjectPath: value }),
     codexAuthPath: (raw, value) => ({ ...raw, codexAuthPath: value }),
     codexHome: (raw, value) => ({ ...raw, codexHome: value }),
+    archivePath: (raw, value) => ({ ...raw, archivePath: value }),
+    scrapMode: (raw, value) => ({ ...raw, scrapMode: value }),
     label: (raw, value) => ({ ...raw, label: value }),
     token: (raw, value) => ({ ...raw, token: value }),
     scopes: (raw, value) => ({ ...raw, scopes: value }),

package/dist/src/docker-git/cli/parser-scrap.js

@@ -0,0 +1,74 @@
+import { Either, Match } from "effect";
+import { parseProjectDirWithOptions } from "./parser-shared.js";
+const missingRequired = (option) => ({
+    _tag: "MissingRequiredOption",
+    option
+});
+const invalidScrapAction = (value) => ({
+    _tag: "InvalidOption",
+    option: "scrap",
+    reason: `unknown action: ${value}`
+});
+const defaultSessionArchiveDir = ".orch/scrap/session";
+const invalidScrapMode = (value) => ({
+    _tag: "InvalidOption",
+    option: "--mode",
+    reason: `unknown value: ${value} (expected session)`
+});
+const parseScrapMode = (raw) => {
+    const value = raw?.trim();
+    if (!value || value.length === 0) {
+        return Either.right("session");
+    }
+    if (value === "session") {
+        return Either.right("session");
+    }
+    if (value === "recipe") {
+        // Backwards/semantic alias: "recipe" behaves like "session" (git state + rebuildable deps).
+        return Either.right("session");
+    }
+    return Either.left(invalidScrapMode(value));
+};
+const makeScrapExportCommand = (projectDir, archivePath, mode) => ({
+    _tag: "ScrapExport",
+    projectDir,
+    archivePath,
+    mode
+});
+const makeScrapImportCommand = (projectDir, archivePath, wipe, mode) => ({
+    _tag: "ScrapImport",
+    projectDir,
+    archivePath,
+    wipe,
+    mode
+});
+// CHANGE: parse scrap session export/import commands
+// WHY: store a small reproducible snapshot (git state + secrets) instead of large caches like node_modules
+// QUOTE(ТЗ): "не должно быть старого режима где он качает весь шлак типо node_modules"
+// REF: user-request-2026-02-15
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseScrap(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<Command, ParseError, never>
+// INVARIANT: export/import always resolves a projectDir
+// COMPLEXITY: O(n) where n = |argv|
+export const parseScrap = (args) => {
+    const action = args[0]?.trim();
+    if (!action || action.length === 0) {
+        return Either.left(missingRequired("scrap <action>"));
+    }
+    const rest = args.slice(1);
+    return Match.value(action).pipe(Match.when("export", () => Either.flatMap(parseProjectDirWithOptions(rest), ({ projectDir, raw }) => Either.map(parseScrapMode(raw.scrapMode), (mode) => {
+        const archivePathRaw = raw.archivePath?.trim();
+        if (archivePathRaw && archivePathRaw.length > 0) {
+            return makeScrapExportCommand(projectDir, archivePathRaw, mode);
+        }
+        return makeScrapExportCommand(projectDir, defaultSessionArchiveDir, mode);
+    }))), Match.when("import", () => Either.flatMap(parseProjectDirWithOptions(rest), ({ projectDir, raw }) => {
+        const archivePath = raw.archivePath?.trim();
+        if (!archivePath || archivePath.length === 0) {
+            return Either.left(missingRequired("--archive"));
+        }
+        return Either.map(parseScrapMode(raw.scrapMode), (mode) => makeScrapImportCommand(projectDir, archivePath, raw.wipe ?? true, mode));
+    })), Match.orElse(() => Either.left(invalidScrapAction(action))));
+};

package/dist/src/docker-git/cli/parser.js

@@ -6,6 +6,7 @@ import { parseClone } from "./parser-clone.js";
 import { buildCreateCommand } from "./parser-create.js";
 import { parseRawOptions } from "./parser-options.js";
 import { parsePanes } from "./parser-panes.js";
+import { parseScrap } from "./parser-scrap.js";
 import { parseSessions } from "./parser-sessions.js";
 import { parseState } from "./parser-state.js";
 import { usageText } from "./usage.js";
@@ -38,5 +39,7 @@ export const parseArgs = (args) => {
         _tag: "UnknownCommand",
         command: command ?? ""
     };
-    return Match.value(command).pipe(Match.when("create", () => parseCreate(rest)), Match.when("init", () => parseCreate(rest)), Match.when("clone", () => parseClone(rest)), Match.when("attach", () => parseAttach(rest)), Match.when("tmux", () => parseAttach(rest)), Match.when("panes", () => parsePanes(rest)), Match.when("terms", () => parsePanes(rest)), Match.when("terminals", () => parsePanes(rest)), Match.when("sessions", () => parseSessions(rest)), Match.when("help", () => Either.right(helpCommand)), Match.when("ps", () => Either.right(statusCommand)), Match.when("status", () => Either.right(statusCommand)), Match.when("down-all", () => Either.right(downAllCommand)), Match.when("stop-all", () => Either.right(downAllCommand)), Match.when("kill-all", () => Either.right(downAllCommand)), Match.when("menu", () => Either.right(menuCommand)), Match.when("ui", () => Either.right(menuCommand)), Match.when("auth", () => parseAuth(rest)), Match.when("state", () => parseState(rest)), Match.orElse(() => Either.left(unknownCommandError)));
+    return Match.value(command)
+        .pipe(Match.when("create", () => parseCreate(rest)), Match.when("init", () => parseCreate(rest)), Match.when("clone", () => parseClone(rest)), Match.when("attach", () => parseAttach(rest)), Match.when("tmux", () => parseAttach(rest)), Match.when("panes", () => parsePanes(rest)), Match.when("terms", () => parsePanes(rest)), Match.when("terminals", () => parsePanes(rest)), Match.when("sessions", () => parseSessions(rest)), Match.when("scrap", () => parseScrap(rest)), Match.when("help", () => Either.right(helpCommand)), Match.when("ps", () => Either.right(statusCommand)), Match.when("status", () => Either.right(statusCommand)), Match.when("down-all", () => Either.right(downAllCommand)), Match.when("stop-all", () => Either.right(downAllCommand)), Match.when("kill-all", () => Either.right(downAllCommand)), Match.when("menu", () => Either.right(menuCommand)), Match.when("ui", () => Either.right(menuCommand)), Match.when("auth", () => parseAuth(rest)), Match.when("state", () => parseState(rest)))
+        .pipe(Match.orElse(() => Either.left(unknownCommandError)));
 };

package/dist/src/docker-git/cli/usage.js

@@ -4,6 +4,7 @@ docker-git create --repo-url <url> [options]
 docker-git clone <url> [options]
 docker-git attach [<url>] [options]
 docker-git panes [<url>] [options]
+docker-git scrap <action> [<url>] [options]
 docker-git sessions [list] [<url>] [options]
 docker-git sessions kill <pid> [<url>] [options]
 docker-git sessions logs <pid> [<url>] [options]
@@ -18,6 +19,7 @@ Commands:
   clone               Create + run container and clone repo
   attach, tmux        Open tmux workspace for a docker-git project
   panes, terms        List tmux panes for a docker-git project
+  scrap               Export/import project scrap (session snapshot + rebuildable deps)
   sessions            List/kill/log container terminal processes
   ps, status          Show docker compose status for all docker-git projects
   down-all            Stop all docker-git containers (docker compose down)
@@ -41,6 +43,9 @@ Options:
   --codex-home <path>       Container path for Codex auth (default: /home/dev/.codex)
   --out-dir <path>          Output directory (default: <projectsRoot>/<org>/<repo>[/issue-<id>|/pr-<id>])
   --project-dir <path>      Project directory for attach (default: .)
+  --archive <path>          Scrap snapshot directory (default: .orch/scrap/session)
+  --mode <session>          Scrap mode (default: session)
+  --wipe | --no-wipe        Wipe workspace before scrap import (default: --wipe)
   --lines <n>               Tail last N lines for sessions logs (default: 200)
   --include-default         Show default/system processes in sessions list
   --up | --no-up            Run docker compose up after init (default: --up)

package/dist/src/docker-git/program.js

@@ -2,6 +2,7 @@ import { createProject } from "@effect-template/lib/usecases/actions";
 import { authCodexLogin, authCodexLogout, authCodexStatus, authGithubLogin, authGithubLogout, authGithubStatus } from "@effect-template/lib/usecases/auth";
 import { renderError } from "@effect-template/lib/usecases/errors";
 import { downAllDockerGitProjects, listProjectStatus } from "@effect-template/lib/usecases/projects";
+import { exportScrap, importScrap } from "@effect-template/lib/usecases/scrap";
 import { stateCommit, stateInit, statePath, statePull, statePush, stateStatus, stateSync } from "@effect-template/lib/usecases/state-repo";
 import { killTerminalProcess, listTerminalSessions, tailTerminalLogs } from "@effect-template/lib/usecases/terminal-sessions";
 import { Effect, Match, pipe } from "effect";
@@ -19,7 +20,9 @@ const setExitCode = (code) => Effect.sync(() => {
 });
 const logWarningAndExit = (error) => pipe(Effect.logWarning(renderError(error)), Effect.tap(() => setExitCode(1)), Effect.asVoid);
 const logErrorAndExit = (error) => pipe(Effect.logError(renderError(error)), Effect.tap(() => setExitCode(1)), Effect.asVoid);
-const handleNonBaseCommand = (command) => Match.value(command).pipe(Match.when({ _tag: "StatePath" }, () => statePath), Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)), Match.when({ _tag: "StateStatus" }, () => stateStatus), Match.when({ _tag: "StatePull" }, () => statePull), Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)), Match.when({ _tag: "StatePush" }, () => statePush), Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)), Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)), Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)), Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)), Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)), Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)), Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)), Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)), Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)), Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)), Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd)), Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)), Match.exhaustive);
+const handleNonBaseCommand = (command) => Match.value(command)
+    .pipe(Match.when({ _tag: "StatePath" }, () => statePath), Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)), Match.when({ _tag: "StateStatus" }, () => stateStatus), Match.when({ _tag: "StatePull" }, () => statePull), Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)), Match.when({ _tag: "StatePush" }, () => statePush), Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)), Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)), Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)), Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)), Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)), Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)), Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)), Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)), Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)), Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)), Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd)), Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)), Match.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)), Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd)))
+    .pipe(Match.exhaustive);
 // CHANGE: compose CLI program with typed errors and shell effects
 // WHY: keep a thin entry layer over pure parsing and template generation
 // QUOTE(ТЗ): "CLI команду... создавать докер образы"
@@ -30,7 +33,7 @@ const handleNonBaseCommand = (command) => Match.value(command).pipe(Match.when({
 // EFFECT: Effect<void, AppError, FileSystem | Path | CommandExecutor>
 // INVARIANT: help is printed without side effects beyond logs
 // COMPLEXITY: O(n) where n = |files|
-export const program = pipe(readCommand, Effect.flatMap((command) => Match.value(command).pipe(Match.when({ _tag: "Help" }, ({ message }) => Effect.log(message)), Match.when({ _tag: "Create" }, (create) => createProject(create)), Match.when({ _tag: "Status" }, () => listProjectStatus), Match.when({ _tag: "DownAll" }, () => downAllDockerGitProjects), Match.when({ _tag: "Menu" }, () => runMenu), Match.orElse((cmd) => handleNonBaseCommand(cmd)))), Effect.catchTag("FileExistsError", (error) => pipe(Effect.logWarning(renderError(error)), Effect.asVoid)), Effect.catchTag("DockerAccessError", logWarningAndExit), Effect.catchTag("DockerCommandError", logWarningAndExit), Effect.catchTag("AuthError", logWarningAndExit), Effect.catchTag("CommandFailedError", logWarningAndExit), Effect.matchEffect({
+export const program = pipe(readCommand, Effect.flatMap((command) => Match.value(command).pipe(Match.when({ _tag: "Help" }, ({ message }) => Effect.log(message)), Match.when({ _tag: "Create" }, (create) => createProject(create)), Match.when({ _tag: "Status" }, () => listProjectStatus), Match.when({ _tag: "DownAll" }, () => downAllDockerGitProjects), Match.when({ _tag: "Menu" }, () => runMenu), Match.orElse((cmd) => handleNonBaseCommand(cmd)))), Effect.catchTag("FileExistsError", (error) => pipe(Effect.logWarning(renderError(error)), Effect.asVoid)), Effect.catchTag("DockerAccessError", logWarningAndExit), Effect.catchTag("DockerCommandError", logWarningAndExit), Effect.catchTag("AuthError", logWarningAndExit), Effect.catchTag("CommandFailedError", logWarningAndExit), Effect.catchTag("ScrapArchiveNotFoundError", logErrorAndExit), Effect.catchTag("ScrapTargetDirUnsupportedError", logErrorAndExit), Effect.catchTag("ScrapWipeRefusedError", logErrorAndExit), Effect.matchEffect({
     onFailure: (error) => isParseError(error)
         ? logErrorAndExit(error)
         : pipe(Effect.logError(renderError(error)), Effect.flatMap(() => Effect.fail(error))),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prover-coder-ai/docker-git",
-  "version": "1.0.8",
+  "version": "1.0.10",
   "description": "Minimal Vite-powered TypeScript console starter using Effect",
   "main": "dist/src/docker-git/main.js",
   "bin": {
@@ -44,9 +44,9 @@
     "build:app": "vite build --ssr src/app/main.ts",
     "dev": "vite build --watch --ssr src/app/main.ts",
     "prelint": "pnpm -C ../lib build",
-    "lint": "npx @ton-ai-core/vibecode-linter src/",
-    "lint:tests": "npx @ton-ai-core/vibecode-linter tests/",
-    "lint:effect": "npx eslint --config eslint.effect-ts-check.config.mjs .",
+    "lint": "PATH=../../scripts:$PATH vibecode-linter src/",
+    "lint:tests": "PATH=../../scripts:$PATH vibecode-linter tests/",
+    "lint:effect": "PATH=../../scripts:$PATH eslint --config eslint.effect-ts-check.config.mjs .",
     "prebuild:docker-git": "pnpm -C ../lib build",
     "build:docker-git": "tsc -p tsconfig.build.json",
     "check": "pnpm run typecheck",

package/src/docker-git/cli/parser-options.ts

@@ -20,6 +20,8 @@ interface ValueOptionSpec {
     | "envProjectPath"
     | "codexAuthPath"
     | "codexHome"
+    | "archivePath"
+    | "scrapMode"
     | "label"
     | "token"
     | "scopes"
@@ -46,6 +48,8 @@ const valueOptionSpecs: ReadonlyArray<ValueOptionSpec> = [
   { flag: "--env-project", key: "envProjectPath" },
   { flag: "--codex-auth", key: "codexAuthPath" },
   { flag: "--codex-home", key: "codexHome" },
+  { flag: "--archive", key: "archivePath" },
+  { flag: "--mode", key: "scrapMode" },
   { flag: "--label", key: "label" },
   { flag: "--token", key: "token" },
   { flag: "--scopes", key: "scopes" },
@@ -69,6 +73,8 @@ const booleanFlagUpdaters: Readonly<Record<string, (raw: RawOptions) => RawOptio
   "--force-env": (raw) => ({ ...raw, forceEnv: true }),
   "--mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: true }),
   "--no-mcp-playwright": (raw) => ({ ...raw, enableMcpPlaywright: false }),
+  "--wipe": (raw) => ({ ...raw, wipe: true }),
+  "--no-wipe": (raw) => ({ ...raw, wipe: false }),
   "--web": (raw) => ({ ...raw, authWeb: true }),
   "--include-default": (raw) => ({ ...raw, includeDefault: true })
 }
@@ -88,6 +94,8 @@ const valueFlagUpdaters: { readonly [K in ValueKey]: (raw: RawOptions, value: st
   envProjectPath: (raw, value) => ({ ...raw, envProjectPath: value }),
   codexAuthPath: (raw, value) => ({ ...raw, codexAuthPath: value }),
   codexHome: (raw, value) => ({ ...raw, codexHome: value }),
+  archivePath: (raw, value) => ({ ...raw, archivePath: value }),
+  scrapMode: (raw, value) => ({ ...raw, scrapMode: value }),
   label: (raw, value) => ({ ...raw, label: value }),
   token: (raw, value) => ({ ...raw, token: value }),
   scopes: (raw, value) => ({ ...raw, scopes: value }),

package/src/docker-git/cli/parser-scrap.ts

@@ -0,0 +1,106 @@
+import { Either, Match } from "effect"
+
+import type { Command, ParseError } from "@effect-template/lib/core/domain"
+
+import { parseProjectDirWithOptions } from "./parser-shared.js"
+
+const missingRequired = (option: string): ParseError => ({
+  _tag: "MissingRequiredOption",
+  option
+})
+
+const invalidScrapAction = (value: string): ParseError => ({
+  _tag: "InvalidOption",
+  option: "scrap",
+  reason: `unknown action: ${value}`
+})
+
+const defaultSessionArchiveDir = ".orch/scrap/session"
+
+const invalidScrapMode = (value: string): ParseError => ({
+  _tag: "InvalidOption",
+  option: "--mode",
+  reason: `unknown value: ${value} (expected session)`
+})
+
+const parseScrapMode = (raw: string | undefined): Either.Either<"session", ParseError> => {
+  const value = raw?.trim()
+  if (!value || value.length === 0) {
+    return Either.right("session")
+  }
+  if (value === "session") {
+    return Either.right("session")
+  }
+  if (value === "recipe") {
+    // Backwards/semantic alias: "recipe" behaves like "session" (git state + rebuildable deps).
+    return Either.right("session")
+  }
+  return Either.left(invalidScrapMode(value))
+}
+
+const makeScrapExportCommand = (projectDir: string, archivePath: string, mode: "session"): Command => ({
+  _tag: "ScrapExport",
+  projectDir,
+  archivePath,
+  mode
+})
+
+const makeScrapImportCommand = (
+  projectDir: string,
+  archivePath: string,
+  wipe: boolean,
+  mode: "session"
+): Command => ({
+  _tag: "ScrapImport",
+  projectDir,
+  archivePath,
+  wipe,
+  mode
+})
+
+// CHANGE: parse scrap session export/import commands
+// WHY: store a small reproducible snapshot (git state + secrets) instead of large caches like node_modules
+// QUOTE(ТЗ): "не должно быть старого режима где он качает весь шлак типо node_modules"
+// REF: user-request-2026-02-15
+// SOURCE: n/a
+// FORMAT THEOREM: forall argv: parseScrap(argv) = cmd -> deterministic(cmd)
+// PURITY: CORE
+// EFFECT: Effect<Command, ParseError, never>
+// INVARIANT: export/import always resolves a projectDir
+// COMPLEXITY: O(n) where n = |argv|
+export const parseScrap = (args: ReadonlyArray<string>): Either.Either<Command, ParseError> => {
+  const action = args[0]?.trim()
+  if (!action || action.length === 0) {
+    return Either.left(missingRequired("scrap <action>"))
+  }
+
+  const rest = args.slice(1)
+
+  return Match.value(action).pipe(
+    Match.when(
+      "export",
+      () =>
+        Either.flatMap(
+          parseProjectDirWithOptions(rest),
+          ({ projectDir, raw }) =>
+            Either.map(parseScrapMode(raw.scrapMode), (mode) => {
+              const archivePathRaw = raw.archivePath?.trim()
+              if (archivePathRaw && archivePathRaw.length > 0) {
+                return makeScrapExportCommand(projectDir, archivePathRaw, mode)
+              }
+              return makeScrapExportCommand(projectDir, defaultSessionArchiveDir, mode)
+            })
+        )
+    ),
+    Match.when("import", () =>
+      Either.flatMap(parseProjectDirWithOptions(rest), ({ projectDir, raw }) => {
+        const archivePath = raw.archivePath?.trim()
+        if (!archivePath || archivePath.length === 0) {
+          return Either.left(missingRequired("--archive"))
+        }
+        return Either.map(parseScrapMode(raw.scrapMode), (mode) =>
+          makeScrapImportCommand(projectDir, archivePath, raw.wipe ?? true, mode))
+      })),
+    Match.orElse(() => Either.left(invalidScrapAction(action)))
+  )
+}

package/src/docker-git/cli/parser.ts

@@ -8,6 +8,7 @@ import { parseClone } from "./parser-clone.js"
 import { buildCreateCommand } from "./parser-create.js"
 import { parseRawOptions } from "./parser-options.js"
 import { parsePanes } from "./parser-panes.js"
+import { parseScrap } from "./parser-scrap.js"
 import { parseSessions } from "./parser-sessions.js"
 import { parseState } from "./parser-state.js"
 import { usageText } from "./usage.js"
@@ -48,26 +49,28 @@ export const parseArgs = (args: ReadonlyArray<string>): Either.Either<Command, P
     command: command ?? ""
   }
 
-  return Match.value(command).pipe(
-    Match.when("create", () => parseCreate(rest)),
-    Match.when("init", () => parseCreate(rest)),
-    Match.when("clone", () => parseClone(rest)),
-    Match.when("attach", () => parseAttach(rest)),
-    Match.when("tmux", () => parseAttach(rest)),
-    Match.when("panes", () => parsePanes(rest)),
-    Match.when("terms", () => parsePanes(rest)),
-    Match.when("terminals", () => parsePanes(rest)),
-    Match.when("sessions", () => parseSessions(rest)),
-    Match.when("help", () => Either.right(helpCommand)),
-    Match.when("ps", () => Either.right(statusCommand)),
-    Match.when("status", () => Either.right(statusCommand)),
-    Match.when("down-all", () => Either.right(downAllCommand)),
-    Match.when("stop-all", () => Either.right(downAllCommand)),
-    Match.when("kill-all", () => Either.right(downAllCommand)),
-    Match.when("menu", () => Either.right(menuCommand)),
-    Match.when("ui", () => Either.right(menuCommand)),
-    Match.when("auth", () => parseAuth(rest)),
-    Match.when("state", () => parseState(rest)),
-    Match.orElse(() => Either.left(unknownCommandError))
-  )
+  return Match.value(command)
+    .pipe(
+      Match.when("create", () => parseCreate(rest)),
+      Match.when("init", () => parseCreate(rest)),
+      Match.when("clone", () => parseClone(rest)),
+      Match.when("attach", () => parseAttach(rest)),
+      Match.when("tmux", () => parseAttach(rest)),
+      Match.when("panes", () => parsePanes(rest)),
+      Match.when("terms", () => parsePanes(rest)),
+      Match.when("terminals", () => parsePanes(rest)),
+      Match.when("sessions", () => parseSessions(rest)),
+      Match.when("scrap", () => parseScrap(rest)),
+      Match.when("help", () => Either.right(helpCommand)),
+      Match.when("ps", () => Either.right(statusCommand)),
+      Match.when("status", () => Either.right(statusCommand)),
+      Match.when("down-all", () => Either.right(downAllCommand)),
+      Match.when("stop-all", () => Either.right(downAllCommand)),
+      Match.when("kill-all", () => Either.right(downAllCommand)),
+      Match.when("menu", () => Either.right(menuCommand)),
+      Match.when("ui", () => Either.right(menuCommand)),
+      Match.when("auth", () => parseAuth(rest)),
+      Match.when("state", () => parseState(rest))
+    )
+    .pipe(Match.orElse(() => Either.left(unknownCommandError)))
 }

package/src/docker-git/cli/usage.ts

@@ -7,6 +7,7 @@ docker-git create --repo-url <url> [options]
 docker-git clone <url> [options]
 docker-git attach [<url>] [options]
 docker-git panes [<url>] [options]
+docker-git scrap <action> [<url>] [options]
 docker-git sessions [list] [<url>] [options]
 docker-git sessions kill <pid> [<url>] [options]
 docker-git sessions logs <pid> [<url>] [options]
@@ -21,6 +22,7 @@ Commands:
   clone               Create + run container and clone repo
   attach, tmux        Open tmux workspace for a docker-git project
   panes, terms        List tmux panes for a docker-git project
+  scrap               Export/import project scrap (session snapshot + rebuildable deps)
   sessions            List/kill/log container terminal processes
   ps, status          Show docker compose status for all docker-git projects
   down-all            Stop all docker-git containers (docker compose down)
@@ -44,6 +46,9 @@ Options:
   --codex-home <path>       Container path for Codex auth (default: /home/dev/.codex)
   --out-dir <path>          Output directory (default: <projectsRoot>/<org>/<repo>[/issue-<id>|/pr-<id>])
   --project-dir <path>      Project directory for attach (default: .)
+  --archive <path>          Scrap snapshot directory (default: .orch/scrap/session)
+  --mode <session>          Scrap mode (default: session)
+  --wipe | --no-wipe        Wipe workspace before scrap import (default: --wipe)
   --lines <n>               Tail last N lines for sessions logs (default: 200)
   --include-default         Show default/system processes in sessions list
   --up | --no-up            Run docker compose up after init (default: --up)

package/src/docker-git/program.ts

@@ -11,6 +11,7 @@ import {
 import type { AppError } from "@effect-template/lib/usecases/errors"
 import { renderError } from "@effect-template/lib/usecases/errors"
 import { downAllDockerGitProjects, listProjectStatus } from "@effect-template/lib/usecases/projects"
+import { exportScrap, importScrap } from "@effect-template/lib/usecases/scrap"
 import {
   stateCommit,
   stateInit,
@@ -68,27 +69,30 @@ type NonBaseCommand = Exclude<
 >
 
 const handleNonBaseCommand = (command: NonBaseCommand) =>
-  Match.value(command).pipe(
-    Match.when({ _tag: "StatePath" }, () => statePath),
-    Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)),
-    Match.when({ _tag: "StateStatus" }, () => stateStatus),
-    Match.when({ _tag: "StatePull" }, () => statePull),
-    Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)),
-    Match.when({ _tag: "StatePush" }, () => statePush),
-    Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)),
-    Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)),
-    Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)),
-    Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)),
-    Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)),
-    Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)),
-    Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)),
-    Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)),
-    Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)),
-    Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)),
-    Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd)),
-    Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)),
-    Match.exhaustive
-  )
+  Match.value(command)
+    .pipe(
+      Match.when({ _tag: "StatePath" }, () => statePath),
+      Match.when({ _tag: "StateInit" }, (cmd) => stateInit(cmd)),
+      Match.when({ _tag: "StateStatus" }, () => stateStatus),
+      Match.when({ _tag: "StatePull" }, () => statePull),
+      Match.when({ _tag: "StateCommit" }, (cmd) => stateCommit(cmd.message)),
+      Match.when({ _tag: "StatePush" }, () => statePush),
+      Match.when({ _tag: "StateSync" }, (cmd) => stateSync(cmd.message)),
+      Match.when({ _tag: "AuthGithubLogin" }, (cmd) => authGithubLogin(cmd)),
+      Match.when({ _tag: "AuthGithubStatus" }, (cmd) => authGithubStatus(cmd)),
+      Match.when({ _tag: "AuthGithubLogout" }, (cmd) => authGithubLogout(cmd)),
+      Match.when({ _tag: "AuthCodexLogin" }, (cmd) => authCodexLogin(cmd)),
+      Match.when({ _tag: "AuthCodexStatus" }, (cmd) => authCodexStatus(cmd)),
+      Match.when({ _tag: "AuthCodexLogout" }, (cmd) => authCodexLogout(cmd)),
+      Match.when({ _tag: "Attach" }, (cmd) => attachTmux(cmd)),
+      Match.when({ _tag: "Panes" }, (cmd) => listTmuxPanes(cmd)),
+      Match.when({ _tag: "SessionsList" }, (cmd) => listTerminalSessions(cmd)),
+      Match.when({ _tag: "SessionsKill" }, (cmd) => killTerminalProcess(cmd)),
+      Match.when({ _tag: "SessionsLogs" }, (cmd) => tailTerminalLogs(cmd)),
+      Match.when({ _tag: "ScrapExport" }, (cmd) => exportScrap(cmd)),
+      Match.when({ _tag: "ScrapImport" }, (cmd) => importScrap(cmd))
+    )
+    .pipe(Match.exhaustive)
 
 // CHANGE: compose CLI program with typed errors and shell effects
 // WHY: keep a thin entry layer over pure parsing and template generation
@@ -121,6 +125,9 @@ export const program = pipe(
   Effect.catchTag("DockerCommandError", logWarningAndExit),
   Effect.catchTag("AuthError", logWarningAndExit),
   Effect.catchTag("CommandFailedError", logWarningAndExit),
+  Effect.catchTag("ScrapArchiveNotFoundError", logErrorAndExit),
+  Effect.catchTag("ScrapTargetDirUnsupportedError", logErrorAndExit),
+  Effect.catchTag("ScrapWipeRefusedError", logErrorAndExit),
   Effect.matchEffect({
     onFailure: (error) =>
       isParseError(error)

package/tests/docker-git/parser.test.ts

@@ -6,6 +6,22 @@ import { parseArgs } from "../../src/docker-git/cli/parser.js"
 
 type CreateCommand = Extract<Command, { _tag: "Create" }>
 
+const expectParseErrorTag = (
+  args: ReadonlyArray<string>,
+  expectedTag: string
+) =>
+  Effect.sync(() => {
+    const parsed = parseArgs(args)
+    Either.match(parsed, {
+      onLeft: (error) => {
+        expect(error._tag).toBe(expectedTag)
+      },
+      onRight: () => {
+        throw new Error("expected parse error")
+      }
+    })
+  })
+
 const parseOrThrow = (args: ReadonlyArray<string>): Command => {
   const parsed = parseArgs(args)
   return Either.match(parsed, {
@@ -56,17 +72,7 @@ describe("parseArgs", () => {
       expect(command.config.volumeName).toBe("dg-repo-issue-9-home")
     }))
 
-  it.effect("fails on missing repo url", () =>
-    Effect.sync(() => {
-      Either.match(parseArgs(["create"]), {
-        onLeft: (error) => {
-          expect(error._tag).toBe("MissingRequiredOption")
-        },
-        onRight: () => {
-          throw new Error("expected parse error")
-        }
-      })
-    }))
+  it.effect("fails on missing repo url", () => expectParseErrorTag(["create"], "MissingRequiredOption"))
 
   it.effect("parses clone command with positional repo url", () =>
     expectCreateCommand(["clone", "https://github.com/org/repo.git"], (command) => {
@@ -169,4 +175,35 @@ describe("parseArgs", () => {
       }
       expect(command.message).toBe("sync state")
     }))
+
+  it.effect("parses scrap export with defaults", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["scrap", "export"])
+      if (command._tag !== "ScrapExport") {
+        throw new Error("expected ScrapExport command")
+      }
+      expect(command.projectDir).toBe(".")
+      expect(command.archivePath).toBe(".orch/scrap/session")
+    }))
+
+  it.effect("fails scrap import without archive", () =>
+    expectParseErrorTag(["scrap", "import"], "MissingRequiredOption"))
+
+  it.effect("parses scrap import wipe defaults", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["scrap", "import", "--archive", "workspace.tar.gz"])
+      if (command._tag !== "ScrapImport") {
+        throw new Error("expected ScrapImport command")
+      }
+      expect(command.wipe).toBe(true)
+    }))
+
+  it.effect("parses scrap import --no-wipe", () =>
+    Effect.sync(() => {
+      const command = parseOrThrow(["scrap", "import", "--archive", "workspace.tar.gz", "--no-wipe"])
+      if (command._tag !== "ScrapImport") {
+        throw new Error("expected ScrapImport command")
+      }
+      expect(command.wipe).toBe(false)
+    }))
 })