@duetso/agent 0.1.201 → 0.2.0

package/README.md

@@ -49,7 +49,7 @@ None of this makes Claude Code or Codex worse at what they do. It makes duet-age
 
 Two things that don't get a section of their own below, but that follow from the same shape:
 
-- **One login, every frontier model.** `duet login` is the whole setup. Claude, GPT, Gemini, image, video, web — all behind one key, with default skills auto-synced and kept fresh.
+- **One login, every frontier model.** `duet login` is the whole setup. Claude, GPT, Gemini, image, video, web — all behind one key.
 - **Open source.** No black box. If we made a wrong call about how memory ranks or how relays route, you can read the code and tell us we're wrong.
 
 ## What we do differently
@@ -251,7 +251,7 @@ The pre-commit hook runs `format`, `check-types`, and `lint`.
 
 ## CLI Quick Start
 
-The recommended path is `duet login`. One sign-in writes `DUET_API_KEY` to `~/.duet/.env`, syncs the default skills, and gives you access to every frontier language, image, and video model on the Duet AI Gateway plus the bundled web-scraping skills — no other API keys required.
+The recommended path is `duet login`. One sign-in writes `DUET_API_KEY` to `~/.duet/.env` and gives you access to every frontier language, image, and video model on the Duet AI Gateway plus the bundled web-scraping skills — no other API keys required.
 
 ```bash
 duet login
@@ -327,12 +327,12 @@ Type `/` in the composer to open the command picker, or send any of these as a m
 - **`/model <name>`** — switch the model used for **subsequent** turns. Accepts the same shorthands and `provider:modelId` forms as the `--model` flag (e.g. `/model sonnet-4.6`, `/model anthropic:claude-opus-4-7`). Unknown shorthands or missing provider credentials surface an error and leave the current model in place. The in-flight turn (if any) keeps the model it started with.
 - **`/thinking <level>`** — switch the thinking level for the **next** turn. One of `minimal`, `low`, `medium`, `high`, `xhigh`. The runner clamps to the active model's supported range at use-time. The in-flight turn (if any) keeps its level.
 - **`/feedback <message>`** — send free-form feedback to the Duet team.
-- **`/reset`** — dispose the current session and start a fresh one.
+- **`/clear`** — dispose the current session and start a fresh one.
 - **`/copy [last|all|<N>]`** — copy transcript text to the system clipboard (default: last agent reply).
 - **`/paste`**, **`/image <path>`**, **`/clear-images`** — image-attachment helpers, covered in the next section.
 - **`/diag`** — toggle key and selection event logging when triaging terminal-specific issues.
 
-`/model`, `/thinking`, `/reset`, `/paste`, `/clear-images`, and `/diag` also work **anywhere inside a longer prompt**. `hey can you review this /model gpt-5.5` swaps the model for the very turn that delivers the message; the slash form is stripped from what the agent sees, so the model receives `hey can you review this`. When the whole prompt is just slash commands, no agent turn runs at all. Commands that take rest-of-line arguments (`/feedback`, `/copy`, `/image`) only fire when they own the whole message.
+`/model`, `/thinking`, `/clear`, `/paste`, `/clear-images`, and `/diag` also work **anywhere inside a longer prompt**. `hey can you review this /model gpt-5.5` swaps the model for the very turn that delivers the message; the slash form is stripped from what the agent sees, so the model receives `hey can you review this`. When the whole prompt is just slash commands, no agent turn runs at all. Commands that take rest-of-line arguments (`/feedback`, `/copy`, `/image`) only fire when they own the whole message.
 
 The inline form also works for the non-TUI one-shot CLI: `duet "hey can you review this /model gpt-5.5"` swaps the model and dispatches the stripped prompt to the agent; `duet "/model gpt-5.5"` applies the swap and exits without dispatching a turn.
 
@@ -353,6 +353,43 @@ The interactive TUI accepts image attachments (PNG, JPEG, GIF, WebP):
 
 </details>
 
+<details>
+<summary><b>Query, recall, and add durable memory from the CLI</b></summary>
+
+The same `~/.duet/memory.db` the runner reads is scriptable from the CLI. Bare `duet memory` opens the interactive TUI; adding `--json` or any filter turns the same invocation into a non-interactive query. Three subcommands cover the write and search paths:
+
+```bash
+# Filter/query mode — bare array of canonical memory objects
+duet memory --json --type reflection --from 2026-06-26
+duet memory --json --source user --session sess_abc123     # rows authored by one session
+
+# Recall — hybrid semantic + keyword search, same pipeline as the recall_memory tool
+duet memory recall wire byte budget cap                     # positional query
+duet memory recall --query "how does the gateway race resolve" --expand
+duet memory recall --scope global --session sess_abc123 --json qwiklabs
+
+# Add — write a single user-authored note
+duet memory add --priority high --tag billing "Enterprise discounts cap at 20%"
+echo "note from a pipe" | duet memory add --source import --session sess_abc123 --json
+```
+
+All three share one **canonical memory JSON object** (`--json`), so a consumer parses one shape everywhere:
+
+- Timestamps are ISO 8601 strings (e.g. `2026-07-06T00:00:00.000Z`); date-only fields (`observedDate`, `referencedDate`) stay `YYYY-MM-DD`.
+- `source` is a flat string — one of `user | agent | system | api | import` (`system` is the training-origin value).
+- `sessionId` is the session that authored the row: writable on `add` via `--session <id>`, filterable on `memory`/`recall` via `--session`, and echoed on output (absent on legacy rows).
+- Two ranking scores are always named explicitly, never a generic `score`: `packScore` (recency × priority × kind bias, present everywhere) and `relevanceScore` (query-relevance, RRF-fused — present only in `memory recall` results).
+
+Command-specific notes:
+
+- **`duet memory` (query):** `--json` emits a bare array ordered by pack score; `--source` and `--session` narrow the set alongside `--type`, `--priority`, `--from`, and `--to`.
+- **`duet memory recall`:** query text comes from `--query <q>` or positional args. `--scope session|global` requires `--session <id>` to compare against; `all` (default) ignores it. `--json` emits a bare array ordered best-first, each row carrying both `packScore` and `relevanceScore`.
+- **`duet memory add`:** added rows are always `note` kind. `--source` defaults to `user`; `--session <id>` stamps the row (omit to leave it global). Content comes from positional args or stdin, and empty input is a usage error. `--json` emits one canonical object (`packScore` and `lastUsedAt` present, `relevanceScore` absent).
+
+Every memory command accepts `--db <absolute-path>` (default `~/.duet/memory.db`) and `--wait <seconds>` (lock-wait budget, default 30; `0` fails immediately). Exit codes are stable for scripting: `0` success, `64` usage or validation error (unknown flag, bad value, empty input), `75` memory-DB lock-wait budget exhausted, and `1` for anything else.
+
+</details>
+
 <details>
 <summary><b>Train a folder of docs into durable memory</b></summary>
 
@@ -383,16 +420,13 @@ The CLI also prints the observation content to stdout, so it's pipeable: `duet t
 <details>
 <summary><b>CLI Login</b></summary>
 
-`duet login` is the recommended setup path. It opens a browser to sign in, writes `DUET_API_KEY` for the selected org to `~/.duet/.env`, and syncs the latest default skills into `~/.duet/skills`.
+`duet login` is the recommended setup path. It opens a browser to sign in and writes `DUET_API_KEY` for the selected org to `~/.duet/.env`.
 
 That single `DUET_API_KEY` is your access token to the Duet AI Gateway: frontier language models (Claude, GPT, Gemini), image generation (GPT Image 2), video generation (Seedance), and the Firecrawl-powered web scraping and search skills, all behind one key.
 
-Once you have synced default skills at least once, every subsequent `duet` invocation refreshes them in the background using a conditional GET against the saved hash. Logging in with `--skip-skill-sync` leaves no hash on disk, so this auto-refresh stays a no-op until you explicitly opt in by syncing once.
-
 ```bash
 duet login
 duet login --no-browser           # print the auth URL instead of opening a browser
-duet login --skip-skill-sync      # skip the post-login default skill sync
 ```
 
 </details>
@@ -508,7 +542,7 @@ const turnRunner = new TurnRunner({
 });
 ```
 
-By default, both `duet` (TUI/run) and `duet --rpc` store durable observations in `~/.duet/memory.db`. Override the path with `--db <path>` (the flag is accepted in both modes and is ignored when `--incognito` is also set), or run with `--incognito` (or `-i`) to set `memoryDbPath: false`, which disables observational memory and compaction for that session. Programmatic callers can pass `memoryDbPath: false` or provide a custom `memoryDbPath`. The CLI's `SessionManager` is a convenience layer that stores session snapshots under `~/.duet/sessions`, but the runner owns memory hydration, pi-turn observation/reflection, compaction, and observation persistence.
+By default, both `duet` (TUI/run) and `duet --rpc` store durable observations in `~/.duet/memory.db`. Override the path with `--db <path>` (the flag is accepted in both modes and is ignored when `--incognito` is also set), or run with `--incognito` (or `-i`) to set `memoryDbPath: false`, which disables observational memory and compaction for that session. `duet --rpc` bypasses `SessionManager`, so it has no session of its own; pass `duet --rpc --session <id>` to attribute every observation written during the RPC process to a caller-owned session (one RPC process is one logical session). Omit it to leave those writes unattributed. Programmatic callers can pass `memoryDbPath: false` or provide a custom `memoryDbPath`. The CLI's `SessionManager` is a convenience layer that stores session snapshots under `~/.duet/sessions`, but the runner owns memory hydration, pi-turn observation/reflection, compaction, and observation persistence.
 
 > [!WARNING]
 > We strongly recommend running with a `memoryDbPath` (the default). Compaction is implemented as part of the observational memory pipeline: raw transcript content is replaced by observations/reflections that the observer and reflector write to the durable store. Without a database, the runner skips that pipeline entirely — there is no compaction, the transcript grows unbounded against the raw model context window, and long sessions will eventually hit a provider context-length error. `memoryDbPath: false` is appropriate for short-lived scripts, tests, and incognito runs that stay well under the model window.

package/dist/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@duetso/agent",
-    "version": "0.1.201",
+    "version": "0.2.0",
     "description": "An opinionated full-stack agent turn runner with native memories, interrupts, and multi-agent orchestration",
     "keywords": [
         "agent",

package/dist/src/cli/help.d.ts

@@ -11,6 +11,7 @@ export declare function printEnvHelp(): void;
 export declare function printSkillsHelp(): void;
 export declare function printMemoryHelp(): void;
 export declare function printMemoryAddHelp(): void;
+export declare function printMemoryRecallHelp(): void;
 export declare function printMemoryReflectHelp(): void;
 export declare function printModelHelp(): void;
 export declare function printTrainHelp(): void;

package/dist/src/cli/help.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAyFtD;AAED,wBAAgB,cAAc,IAAI,IAAI,CA0BrC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAsBnC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAqBtC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAuDtC;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CAyBzC;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAuC7C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAsCrC;AAED,wBAAgB,cAAc,IAAI,IAAI,CA+DrC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAiB5C;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAe1D"}
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,IAAI,CAAC;AAEjD,wBAAgB,YAAY,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CA0FtD;AAED,wBAAgB,cAAc,IAAI,IAAI,CAqBrC;AAED,wBAAgB,YAAY,IAAI,IAAI,CAsBnC;AAED,wBAAgB,eAAe,IAAI,IAAI,CAqBtC;AAED,wBAAgB,eAAe,IAAI,IAAI,CA4DtC;AAED,wBAAgB,kBAAkB,IAAI,IAAI,CA8BzC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAwC5C;AAED,wBAAgB,sBAAsB,IAAI,IAAI,CAuC7C;AAED,wBAAgB,cAAc,IAAI,IAAI,CAsCrC;AAED,wBAAgB,cAAc,IAAI,IAAI,CA+DrC;AAED,wBAAgB,qBAAqB,IAAI,IAAI,CAiB5C;AAED,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,IAAI,CAe1D"}

package/dist/src/cli/help.js

@@ -12,7 +12,7 @@ duet — An opinionated full-stack agent runner
 
 USAGE
   duet [options] [prompt]
-  duet login [--no-browser] [--skip-skill-sync]
+  duet login --workspace <slug> [--no-browser]
   duet env [--env-file <path>] [--import [path]|--keys]
   duet skills [--workdir <path>]
   duet memory [--db <path>] [--json] [filters]
@@ -22,7 +22,7 @@ USAGE
   echo "prompt" | duet
 
 COMMANDS
-  login                    Sign in via browser; saves DUET_API_KEY and syncs default skills (recommended)
+  login                    Sign in via device flow; saves a workspace-scoped DUET_API_KEY (recommended)
   env                      Manually create or update the shared duet env file with provider API keys
   skills                   List installed skills + collisions as JSON
   memory                   Browse memories in a TUI, or query them with --json/filters (alias: memories)
@@ -48,11 +48,12 @@ OPTIONS
   --no-system-prompt-files Disable default AGENTS.md system prompt loading
   --env-file <path>        Shared env file to load after <workdir>/.env (default: ${DEFAULT_DUET_ENV_FILE})
   --no-auto-upgrade         Skip the auto-upgrade probe for this run (also: DUET_NO_AUTO_UPGRADE=1)
-  --no-skill-sync           Skip the on-load default-skill sync
   --rpc                     Bare turn-runner control surface. Reads newline-delimited TurnRunnerCommand
                             JSON from stdin and writes TurnEvent JSON to stdout. The first command must
                             be "start"; the process exits after the single turn reaches its terminal
                             event. Bypasses session persistence entirely.
+  --session <id>            (--rpc only) Attribute memory written during the process to this caller-owned
+                            session id. One RPC process is one logical session; omit to write with no id.
   -v, --version            Print the installed duet version and exit
   -h, --help               Show this help
 
@@ -70,9 +71,9 @@ MODELS
   OPENAI_API_KEY after loading <workdir>/.env and the shared duet env file.
 
   duet-gateway: routes through the Duet gateway proxy
-  (https://duet.so/api/v1/ai-gateway by default; override the app origin
-  via DUET_APP_BASE_URL). It mirrors vercel-ai-gateway's model catalog
-  and authenticates with DUET_API_KEY.
+  (https://gateway.duet.so by default; override via DUET_GATEWAY_BASE_URL).
+  It mirrors vercel-ai-gateway's model catalog and authenticates with
+  DUET_API_KEY.
 
 EXAMPLES
   duet "build a REST API with Express and TypeScript"
@@ -86,7 +87,7 @@ EXAMPLES
   duet --env-file ~/.config/duet/env "review this repo"
   duet --workdir ./my-project "refactor the auth module"
   duet --resume session_abc123 --workdir ./my-project
-  duet login
+  duet login --workspace acme
   duet env
   duet memory
   duet model -m openai/gpt-5.5 "write a haiku about gateways"
@@ -98,29 +99,24 @@ EXAMPLES
 }
 export function printLoginHelp() {
     console.log(`
-duet login — Sign in via browser and sync default skills
+duet login — Sign in via device flow
 
 USAGE
-  duet login [--env-file <path>] [--no-browser] [--skip-skill-sync]
+  duet login --workspace <slug> [--env-file <path>] [--no-browser]
 
-Opens a browser window pointed at the Duet web app, waits for the user to
-confirm, then writes the org's DUET_API_KEY to the shared env file. After
-auth, fetches and writes the latest default skills to ~/.duet/skills.
+Requests a workspace-scoped device code, prints the user code and verification
+URL, waits for approval, then writes the workspace's DUET_API_KEY to the shared
+env file.
 
 OPTIONS
+  --workspace <slug>       Workspace slug for the one-workspace API key (or DUET_WORKSPACE)
   --env-file <path>        Env file to write the API key to (default: ${DEFAULT_DUET_ENV_FILE})
-  --no-browser             Print the auth URL instead of opening a browser
-  --skip-skill-sync        Skip the post-login default skills sync
+  --no-browser             Print the verification URL instead of opening a browser
   -h, --help               Show this help
 
-SKILL SYNC
-  Mirrors the sandbox protocol: hashes the rendered skill payload and only
-  rewrites ~/.duet/skills when the hash differs from ~/.duet/.skills-hash.
-
 OVERRIDES
-  Set DUET_APP_BASE_URL (e.g. https://staging.duet.so) to re-point both the
-  AI gateway provider and the CLI auth/sync endpoints at a non-production
-  deployment.
+  Set DUET_API_BASE_URL (e.g. https://api-staging.duet.so) to re-point device
+  login. Model traffic uses DUET_GATEWAY_BASE_URL.
 `);
 }
 export function printEnvHelp() {
@@ -175,7 +171,7 @@ duet memory — Browse, query, edit, and delete observational memories
 USAGE
   duet memory [--db <path>] [--wait <seconds>]
   duet memory [--json] [--type <kind>] [--priority <level>] [--source <origin>]
-              [--from <date>] [--to <date>]
+              [--session <id>] [--from <date>] [--to <date>]
   duet memory reflect [options]
 
 ALIASES
@@ -185,9 +181,10 @@ DESCRIPTION
   Bare \`duet memory\` opens an interactive TUI to browse, edit, and delete
   durable observations. Passing --json or any filter flag instead runs a
   non-TUI, scriptable query: it prints a flat, chronological list (newest
-  createdAt first) of the matching observations, each carrying a computed
-  \`score\` field matching the runner's global-pack ranking. With --json the
-  output is a machine-readable array; otherwise an aligned table is printed.
+  createdAt first) of the matching observations. In table mode each row shows
+  a computed \`score\` matching the runner's global-pack ranking; --json emits
+  a machine-readable array of canonical memory objects (ISO timestamps, flat
+  \`source\` string, echoed \`sessionId\`, and that score as \`packScore\`).
 
   Examples:
     duet memory
@@ -197,6 +194,9 @@ DESCRIPTION
 SUBCOMMANDS
   add                      Write a single user-added note memory
                            (run \`duet memory add --help\` for add-specific options)
+  recall <query>           Hybrid semantic + keyword search over durable memory,
+                           the same pipeline the runner's recall_memory tool uses
+                           (run \`duet memory recall --help\` for recall-specific options)
   reflect                  Condense old global observations into reflection rows
                            (run \`duet memory reflect --help\` for reflect-specific options)
 
@@ -205,7 +205,8 @@ QUERY OPTIONS
   --type <kind>            Filter by kind: observation | reflection | note | manual
   --kind <kind>            Alias for --type
   --priority <level>       Filter by priority: high | medium | low
-  --source <origin>        Filter by source: user | agent | system
+  --source <origin>        Filter by source: user | agent | system | api | import
+  --session <id>           Filter to rows authored by this session id
   --from <date>            Inclusive lower bound on createdAt. Accepts
                            YYYY-MM-DD (start of day UTC) or YYYY-MM-DDTHH:MM:SS (UTC)
   --to <date>              Inclusive upper bound on createdAt. Accepts
@@ -243,8 +244,54 @@ DESCRIPTION
 
 OPTIONS
   --priority <level>       high, medium, or low (default: medium)
+  --source <origin>        user, agent, system, api, or import (default: user)
+  --session <id>           Stamp the row's authoring session; omit to leave it
+                           global/unattributed
   --tag <tag>              Attach a label; repeat to add several
   --db <path>              Memory database path (default: ~/.duet/memory.db)
+  --json                   Emit the stored memory as one canonical JSON object
+                           (with packScore) instead of the confirmation line
+  --wait <seconds>         Seconds to wait for the cross-process open-lock
+                           (default: 30; 0 fails immediately)
+  -h, --help               Show this help
+`);
+}
+export function printMemoryRecallHelp() {
+    console.log(`
+duet memory recall — Hybrid semantic + keyword search over durable memory
+
+USAGE
+  duet memory recall [options] [--query <q> | <query...>]
+
+DESCRIPTION
+  Searches ~/.duet/memory.db with the exact pipeline the runner's
+  recall_memory tool uses: vector (embedding) search and keyword search run
+  in parallel and merge via Reciprocal Rank Fusion, so fuzzy paraphrases and
+  exact tokens (proper nouns, IDs, code symbols) both match. Results print
+  best-match first.
+
+  Embeddings use the Duet endpoint (DUET_API_KEY). When it is unavailable the
+  vector path is skipped and recall falls back to keyword-only, flagged in the
+  output. --expand adds model-generated paraphrases before fusion for vague
+  queries, at the cost of an extra model call.
+
+  Examples:
+    duet memory recall wire byte budget cap
+    duet memory recall --expand "how does the gateway race resolve"
+    duet memory recall --scope global --session <id> --json qwiklabs
+
+OPTIONS
+  --query <q>              Search text (alternative to positional <query>;
+                           both are accepted and combine)
+  --scope <scope>          session | global | all (default: all).
+                           session/global require --session <id>
+  --session <id>           Session id to compare against for --scope session/global
+  --limit <n>              Maximum fused results to return (default: 8)
+  --expand                 Also run model-generated paraphrases before fusion
+  --model <name>           Model used for --expand paraphrases (default: cheap CLI memory model)
+  --json                   Emit a bare JSON array of canonical memory objects
+                           (best-first) with packScore + relevanceScore
+  --db <path>              Memory database path (default: ~/.duet/memory.db)
   --wait <seconds>         Seconds to wait for the cross-process open-lock
                            (default: 30; 0 fails immediately)
   -h, --help               Show this help

package/dist/src/cli/help.js.map

@@ -1 +1 @@
-{"version":3,"file":"help.js","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC;AAEjD,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;gDAqBkC,WAAW;;;;;;;;;;;;;gHAaqD,+BAA+B;;;;;oFAK3D,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgDxG,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;wEAW0D,qBAAqB;;;;;;;;;;;;;CAa5F,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;yDAa2C,qBAAqB;;;;;;IAM1E,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;CAChC,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;CAmBb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqDb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;CAuBb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;CAeb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,GAAG,CAAC;oCACsB,WAAW;;;;;;;;;;;;CAY9C,CAAC,CAAC;AACH,CAAC"}
+{"version":3,"file":"help.js","sourceRoot":"","sources":["../../../src/cli/help.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAC;AAExE;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,CAAC,CAAC;AAEjD,MAAM,UAAU,YAAY,CAAC,WAAmB;IAC9C,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;gDAqBkC,WAAW;;;;;;;;;;;;;gHAaqD,+BAA+B;;;;;oFAK3D,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiDxG,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;wEAY0D,qBAAqB;;;;;;;CAO5F,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,YAAY;IAC1B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;yDAa2C,qBAAqB;;;;;;IAM1E,kBAAkB,CAAC,IAAI,CAAC,IAAI,CAAC;CAChC,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;CAmBb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,kBAAkB;IAChC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4Bb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,sBAAsB;IACpC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoCb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,cAAc;IAC5B,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6Db,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,qBAAqB;IACnC,OAAO,CAAC,GAAG,CAAC;;;;;;;;;;;;;;;CAeb,CAAC,CAAC;AACH,CAAC;AAED,MAAM,UAAU,gBAAgB,CAAC,WAAmB;IAClD,OAAO,CAAC,GAAG,CAAC;oCACsB,WAAW;;;;;;;;;;;;CAY9C,CAAC,CAAC;AACH,CAAC"}

package/dist/src/cli/inline-slash.js

@@ -1,7 +1,7 @@
 import { resolveModelName } from "../model-resolution/resolver.js";
 import { validateThinkingLevel } from "../session/thinking-level.js";
 import { applyInlineSlashCommands } from "../tui/slash-commands.js";
-/** Slash commands the non-TUI CLI applies inline. /reset, /paste, /clear-images, /diag
+/** Slash commands the non-TUI CLI applies inline. /clear, /paste, /clear-images, /diag
  *  have no meaning in a one-shot run so the CLI intentionally ignores them. */
 const CLI_INLINE_COMMANDS = new Set(["model", "thinking"]);
 /**

package/dist/src/cli/login.d.ts

@@ -5,9 +5,8 @@ export interface LoginCommandIO {
 /**
  * Run `duet login`.
  *
- * Opens the duet web app in a browser, waits for confirmation, persists the
- * returned `DUET_API_KEY` to the shared env file, then optionally syncs the
- * org's default skills bundle to `~/.duet/skills`.
+ * Starts the Duet device flow for a workspace-scoped API key and persists the
+ * returned `DUET_API_KEY` to the shared env file.
  */
 export declare function runLoginCommand(args: string[], io?: LoginCommandIO): Promise<void>;
 //# sourceMappingURL=login.d.ts.map

package/dist/src/cli/login.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/cli/login.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;;GAMG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CA2D5F"}
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../../src/cli/login.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,GAAE,cAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgD5F"}

package/dist/src/cli/login.js

@@ -1,20 +1,17 @@
-import { resolveDuetAppBaseUrl } from "../lib/duet-app-url.js";
-import { loginWithBrowser } from "../lib/login.js";
-import { syncDefaultSkills } from "../lib/sync-skills.js";
+import { loginWithDeviceFlow } from "../lib/login.js";
 import { printLoginHelp } from "./help.js";
-import { defaultDuetEnvFilePath, fail, mergeEnvEntries, resolveUserPath } from "./shared.js";
+import { defaultDuetEnvFilePath, fail, mergeEnvEntries, resolveUserPath, usageError, } from "./shared.js";
 /**
  * Run `duet login`.
  *
- * Opens the duet web app in a browser, waits for confirmation, persists the
- * returned `DUET_API_KEY` to the shared env file, then optionally syncs the
- * org's default skills bundle to `~/.duet/skills`.
+ * Starts the Duet device flow for a workspace-scoped API key and persists the
+ * returned `DUET_API_KEY` to the shared env file.
  */
 export async function runLoginCommand(args, io = {}) {
     const cwd = io.cwd ?? process.cwd();
     let envFilePathOverride = io.envFilePath;
     let noBrowser = false;
-    let skipSkillSync = false;
+    let workspaceSlug;
     for (let i = 0; i < args.length; i++) {
         switch (args[i]) {
             case "--env-file":
@@ -26,7 +23,12 @@ export async function runLoginCommand(args, io = {}) {
                 noBrowser = true;
                 break;
             case "--skip-skill-sync":
-                skipSkillSync = true;
+                // Deprecated no-op; tolerated so scripts that pass it do not break.
+                break;
+            case "--workspace":
+                if (!args[i + 1] || args[i + 1]?.startsWith("-"))
+                    fail(`Missing value for ${args[i]}`);
+                workspaceSlug = args[++i];
                 break;
             case "--help":
             case "-h":
@@ -36,32 +38,15 @@ export async function runLoginCommand(args, io = {}) {
                 fail(`Unknown login option: ${args[i]}`);
         }
     }
+    workspaceSlug = workspaceSlug?.trim() || process.env.DUET_WORKSPACE?.trim();
+    if (!workspaceSlug) {
+        usageError("Missing required workspace. Pass `duet login --workspace <slug>` or set DUET_WORKSPACE; login creates one DUET_API_KEY scoped to one workspace.");
+    }
     const targetEnvFile = envFilePathOverride
         ? resolveUserPath(envFilePathOverride, cwd)
         : defaultDuetEnvFilePath();
-    const result = await loginWithBrowser({ noBrowser });
+    const result = await loginWithDeviceFlow({ noBrowser, workspaceSlug });
     await mergeEnvEntries(targetEnvFile, new Map([["DUET_API_KEY", result.apiKey]]));
-    console.error(`Saved DUET_API_KEY for ${result.orgName} (${result.orgSlug}) to ${targetEnvFile}`);
-    process.env.DUET_API_KEY = result.apiKey;
-    await fetch(`${resolveDuetAppBaseUrl()}/api/v1/analytics/events`, {
-        method: "POST",
-        headers: {
-            Authorization: `Bearer ${result.apiKey}`,
-            "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ name: "cli_login" }),
-    }).catch(() => { });
-    if (skipSkillSync) {
-        console.error("Skipping default skill sync (--skip-skill-sync).");
-        return;
-    }
-    console.error(`Checking default skills against ${resolveDuetAppBaseUrl()}...`);
-    const syncResult = await syncDefaultSkills({ apiKey: result.apiKey });
-    if (syncResult.status === "unchanged") {
-        console.error("Default skills already up to date.");
-    }
-    else {
-        console.error(`Synced default skills (${syncResult.count} total).`);
-    }
+    console.error(`Saved DUET_API_KEY for ${result.workspaceName} (${result.workspaceSlug}) to ${targetEnvFile}`);
 }
 //# sourceMappingURL=login.js.map

package/dist/src/cli/login.js.map

@@ -1 +1 @@
-{"version":3,"file":"login.js","sourceRoot":"","sources":["../../../src/cli/login.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"login.js","sourceRoot":"","sources":["../../../src/cli/login.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAC3C,OAAO,EACL,sBAAsB,EACtB,IAAI,EACJ,eAAe,EACf,eAAe,EACf,UAAU,GACX,MAAM,aAAa,CAAC;AAOrB;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,IAAc,EAAE,KAAqB,EAAE;IAC3E,MAAM,GAAG,GAAG,EAAE,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,EAAE,CAAC;IACpC,IAAI,mBAAmB,GAAuB,EAAE,CAAC,WAAW,CAAC;IAC7D,IAAI,SAAS,GAAG,KAAK,CAAC;IACtB,IAAI,aAAiC,CAAC;IAEtC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACrC,QAAQ,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;YAChB,KAAK,YAAY;gBACf,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC;oBAAE,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACvF,mBAAmB,GAAG,IAAI,CAAC,EAAE,CAAC,CAAE,CAAC;gBACjC,MAAM;YACR,KAAK,cAAc;gBACjB,SAAS,GAAG,IAAI,CAAC;gBACjB,MAAM;YACR,KAAK,mBAAmB;gBACtB,oEAAoE;gBACpE,MAAM;YACR,KAAK,aAAa;gBAChB,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,EAAE,UAAU,CAAC,GAAG,CAAC;oBAAE,IAAI,CAAC,qBAAqB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;gBACvF,aAAa,GAAG,IAAI,CAAC,EAAE,CAAC,CAAE,CAAC;gBAC3B,MAAM;YACR,KAAK,QAAQ,CAAC;YACd,KAAK,IAAI;gBACP,cAAc,EAAE,CAAC;gBACjB,OAAO;YACT;gBACE,IAAI,CAAC,yBAAyB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;QAC7C,CAAC;IACH,CAAC;IAED,aAAa,GAAG,aAAa,EAAE,IAAI,EAAE,IAAI,OAAO,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,EAAE,CAAC;IAC5E,IAAI,CAAC,aAAa,EAAE,CAAC;QACnB,UAAU,CACR,iJAAiJ,CAClJ,CAAC;IACJ,CAAC;IAED,MAAM,aAAa,GAAG,mBAAmB;QACvC,CAAC,CAAC,eAAe,CAAC,mBAAmB,EAAE,GAAG,CAAC;QAC3C,CAAC,CAAC,sBAAsB,EAAE,CAAC;IAE7B,MAAM,MAAM,GAAG,MAAM,mBAAmB,CAAC,EAAE,SAAS,EAAE,aAAa,EAAE,CAAC,CAAC;IAEvE,MAAM,eAAe,CAAC,aAAa,EAAE,IAAI,GAAG,CAAC,CAAC,CAAC,cAAc,EAAE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IACjF,OAAO,CAAC,KAAK,CACX,0BAA0B,MAAM,CAAC,aAAa,KAAK,MAAM,CAAC,aAAa,QAAQ,aAAa,EAAE,CAC/F,CAAC;AACJ,CAAC"}

package/dist/src/cli/memory-add.d.ts

@@ -1,10 +1,17 @@
-import type { ObservationPriority } from "../types/memory.js";
+import type { ObservationPriority, ObservationSource } from "../types/memory.js";
+type SourceKind = ObservationSource["kind"];
 interface AddCommandOptions {
     dbPath: string;
     /** Positional content joined with spaces; empty when the caller pipes via stdin instead. */
     content: string;
     priority: ObservationPriority;
+    /** Provenance stamped on the row and echoed back; defaults to `user`. */
+    source: SourceKind;
     tags: string[];
+    /** Session that authored the row; omitted leaves the row global/unattributed. */
+    sessionId?: string;
+    /** Emit one canonical memory JSON object instead of the human line. */
+    json: boolean;
     waitBudgetMs?: number;
 }
 interface AddCommandIO {

package/dist/src/cli/memory-add.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory-add.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAK9D,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,cAAc,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,YAA+D,GAClE,OAAO,CAAC,IAAI,CAAC,CA+Cf;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CAoDhF"}
+{"version":3,"file":"memory-add.d.ts","sourceRoot":"","sources":["../../../src/cli/memory-add.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAOjF,KAAK,UAAU,GAAG,iBAAiB,CAAC,MAAM,CAAC,CAAC;AAE5C,UAAU,iBAAiB;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,mBAAmB,CAAC;IAC9B,yEAAyE;IACzE,MAAM,EAAE,UAAU,CAAC;IACnB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,uEAAuE;IACvE,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC,cAAc,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC,cAAc,GAAG;QAAE,KAAK,CAAC,EAAE,OAAO,CAAA;KAAE,CAAC;CACpD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,MAAM,EAAE,EACd,EAAE,GAAE,YAA+D,GAClE,OAAO,CAAC,IAAI,CAAC,CAqCf;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,iBAAiB,GAAG,SAAS,CA+DhF"}