orizu 0.5.9 → 0.5.11

package/dist/daytona-slice-rehearsal.js

@@ -51,17 +51,17 @@ export function seedLocalBareRepo(baseDir, config) {
     const work = mkdtempSync(join(baseDir, 'seed-'));
     gitOrThrow(['init', '--initial-branch=main', work]);
     const ident = ['-c', 'user.email=seed@orizu.local', '-c', 'user.name=Seed'];
+    // ALI-1075: no `canonical`/`repoState` liveness fields — manifests carry
+    // machine-readable ids only; the DB label is the sole production pointer.
     const teamManifest = {
         schemaVersion: WORKSPACE_SCHEMA_VERSION,
         kind: 'team',
         slug: config.teamSlug,
-        canonical: { owner: 'repo', repoState: 'source', objectRef: null },
     };
     const projectManifest = {
         schemaVersion: WORKSPACE_SCHEMA_VERSION,
         kind: 'project',
         slug: config.projectSlug,
-        canonical: { owner: 'repo', repoState: 'draft', objectRef: null },
     };
     writeFileSync(join(work, 'orizu.team.json'), `${JSON.stringify(teamManifest, null, 2)}\n`);
     writeFileSync(join(work, '.gitignore'), '# Orizu workspace policy\n.orizu/\n');

package/dist/daytona-slice.js

@@ -23,6 +23,7 @@
  *      branch → approve → apply via the API, then destroy the sandbox.
  */
 import { WORKSPACE_SCHEMA_VERSION } from './workspace.js';
+import { sweepForTokenResidue } from './sandbox-hygiene.js';
 const REPO_DIR = 'repo';
 const DEFAULT_GENERATED_FILE = 'orizu-slice-note.md';
 const STEP_PLAN = [
@@ -118,57 +119,6 @@ async function mintRepoToken(fetcher, workspaceId, purpose, sessionId) {
         expiresAt: typeof body.expiresAt === 'string' ? body.expiresAt : null,
     };
 }
-/**
- * The list of places a short-lived git token can leak inside a sandbox after a
- * transient clone+push. List-driven so it is trivial to extend. `${repo}` is
- * substituted with the repo path. Ordered from the repo-local stores outward to
- * global config, the credential cache, the reflog, shell history, and the live
- * process listing / argv — the exact surfaces the Daytona-support question names.
- */
-export function tokenLeakProbes(repoPath) {
-    const R = repoPath;
-    return [
-        { location: `${R}/.git/config`, command: `cat ${R}/.git/config 2>/dev/null || true` },
-        { location: `${R}/.git/logs (reflog)`, command: `find ${R}/.git/logs -type f -exec cat {} + 2>/dev/null || true` },
-        { location: '~/.git-credentials', command: 'cat "$HOME/.git-credentials" 2>/dev/null || true' },
-        { location: '~/.gitconfig (global)', command: 'cat "$HOME/.gitconfig" 2>/dev/null || true' },
-        { location: 'git credential cache/store', command: 'cat "$HOME/.cache/git/credential/"* "${XDG_CACHE_HOME:-$HOME/.cache}/git/credential/"* 2>/dev/null || true' },
-        { location: 'shell history', command: 'cat "$HOME/.bash_history" "$HOME/.zsh_history" 2>/dev/null || true' },
-        { location: 'process listing / argv', command: 'ps -eo args 2>/dev/null || ps aux 2>/dev/null || true' },
-        { location: 'process env', command: 'env' },
-    ];
-}
-/**
- * Grep the sandbox filesystem + process table for token values and the
- * `x-access-token` marker across every known leak surface (see `tokenLeakProbes`).
- * Returns every finding; an empty array means the transient operations left no
- * residue. This is the load-bearing check the whole slice exists to make.
- *
- * NOTE (local-sim): the reflog/config/credential-store/history probes run
- * meaningfully in local-sim, but `ps`/argv coverage is only decisive on the live
- * Daytona run (local-sim runs the git clone via a child process on the host, not
- * inside an isolated PID namespace). The WS-F memo marks that probe live-only.
- */
-export async function sweepForTokenResidue(session, opts) {
-    const markers = opts.markers ?? ['x-access-token'];
-    const tokens = opts.tokens.filter(token => token.length > 0);
-    const probes = opts.probes ?? tokenLeakProbes(opts.repoPath);
-    const findings = [];
-    for (const probe of probes) {
-        const { stdout } = await session.exec(probe.command);
-        for (const token of tokens) {
-            if (stdout.includes(token)) {
-                findings.push({ location: probe.location, marker: 'token-value' });
-            }
-        }
-        for (const marker of markers) {
-            if (stdout.includes(marker)) {
-                findings.push({ location: probe.location, marker });
-            }
-        }
-    }
-    return findings;
-}
 // -- The workflow ------------------------------------------------------------
 /**
  * Run a command in the sandbox and throw on a non-zero (or missing) exit code,

package/dist/git-credential.js

@@ -45,17 +45,20 @@ export function resolveAttachedWorkspaceId(cwd) {
         const manifestPath = join(dir, 'orizu.team.json');
         if (existsSync(manifestPath)) {
             const manifest = readJsonManifest(manifestPath);
-            const canonical = manifest?.canonical;
-            const serviceId = canonical && typeof canonical === 'object' && !Array.isArray(canonical)
-                ? canonical.serviceId
-                : null;
-            if (typeof serviceId === 'string' && serviceId)
-                return serviceId;
+            // `setup.attachedWorkspaceId` is the attachment id; `canonical.serviceId`
+            // is a legacy duplicate kept only as a read fallback for old repos
+            // (ALI-1075: fresh manifests carry no `canonical` block).
             const setup = manifest?.setup;
             const attached = setup && typeof setup === 'object' && !Array.isArray(setup)
                 ? setup.attachedWorkspaceId
                 : null;
-            return typeof attached === 'string' && attached ? attached : null;
+            if (typeof attached === 'string' && attached)
+                return attached;
+            const canonical = manifest?.canonical;
+            const serviceId = canonical && typeof canonical === 'object' && !Array.isArray(canonical)
+                ? canonical.serviceId
+                : null;
+            return typeof serviceId === 'string' && serviceId ? serviceId : null;
         }
         const parent = dirname(dir);
         if (parent === dir)

package/dist/github-setup.js

@@ -14,7 +14,7 @@
  *      is immediately rewritten to a clean origin.
  */
 import { spawnSync } from 'child_process';
-import { mkdirSync } from 'fs';
+import { existsSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { authedFetch } from './http.js';
 import { assertWorkspaceDirUsable } from './workspace.js';
@@ -196,6 +196,23 @@ export async function runHostedAttach(options, io) {
         }
     }
     const cleanUrl = `https://github.com/${repoFullName}.git`;
+    const ensureOrizuDir = io.ensureOrizuDir ?? ((repoDir) => mkdirSync(join(repoDir, '.orizu'), { recursive: true }));
+    // Idempotent re-run (ALI-1069): `orizu setup` in an ALREADY-attached workspace
+    // reaches here with `targetDir` holding the prior clone (its `.git` plus the
+    // committed orizu.team.json — `assertWorkspaceDirUsable` deliberately exempts
+    // that dir as the idempotent case). `git clone` refuses ANY non-empty dir, so
+    // an unconditional clone would abort the re-run with a misleading "not an empty
+    // directory" error. Short-circuit: re-affirm the credential helper config
+    // (idempotent) and return without recloning.
+    const repoAlreadyCloned = io.repoAlreadyCloned ?? ((dir) => existsSync(join(dir, '.git')));
+    if (repoAlreadyCloned(options.targetDir)) {
+        io.print('   Workbench repo already attached — skipping clone.');
+        gitOrThrow(io.git, ['config', 'credential.helper', CREDENTIAL_HELPER], { cwd: options.targetDir });
+        gitOrThrow(io.git, ['config', 'credential.useHttpPath', 'true'], { cwd: options.targetDir });
+        ensureOrizuDir(options.targetDir);
+        io.print('   Attached. Configured the Orizu credential helper for git.');
+        return { repoFullName, provisioned, targetDir: options.targetDir };
+    }
     io.print(`   Cloning ${repoFullName}...`);
     // Clone with the helper inline + the workspace id in the env so the token is
     // brokered on demand and never materializes in the URL or on disk.
@@ -211,7 +228,6 @@ export async function runHostedAttach(options, io) {
     // Persist the helper repo-locally for future pull/push (cwd-resolved).
     gitOrThrow(io.git, ['config', 'credential.helper', CREDENTIAL_HELPER], { cwd: options.targetDir });
     gitOrThrow(io.git, ['config', 'credential.useHttpPath', 'true'], { cwd: options.targetDir });
-    const ensureOrizuDir = io.ensureOrizuDir ?? ((repoDir) => mkdirSync(join(repoDir, '.orizu'), { recursive: true }));
     ensureOrizuDir(options.targetDir);
     io.print('   Attached. Configured the Orizu credential helper for git.');
     return { repoFullName, provisioned, targetDir: options.targetDir };

package/dist/help.js

@@ -318,8 +318,8 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['prompts', 'push'],
-        usage: 'orizu prompts push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--json]',
-        summary: 'Push a local prompt artifact directory as a new version.',
+        usage: 'orizu prompts push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--json]',
+        summary: 'Push a local prompt artifact directory as a new version (with --session: a commit-first git draft).',
         group: 'Prompts and judges',
     },
     {
@@ -354,8 +354,8 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['judges', 'push'],
-        usage: 'orizu judges push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--json]',
-        summary: 'Push a local judge artifact directory as a new version.',
+        usage: 'orizu judges push <dir> [--runner-version <id>] [--project <team/project>] [--parent <version-id>] [--session <session-id>] [--json]',
+        summary: 'Push a local judge artifact directory as a new version (with --session: a commit-first git draft).',
         group: 'Prompts and judges',
     },
     {
@@ -747,23 +747,25 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['session', 'start'],
-        usage: 'orizu session start [--project <team/project>] [--json]',
-        summary: 'Start a durable workspace session for the attached workspace and print the session id for later resume.',
+        usage: 'orizu session start [--project <team/project>] [--workspace <dir>] [--json]',
+        summary: 'Start a durable workspace session and print the session id. When run inside the workbench clone (or with --workspace), the remote session branch is fetched and checked out locally, and the exact next git commands are printed.',
         group: 'Sessions',
         options: [
             { name: '--project <team/project>', help: 'Optionally scope the session to a project in the attached workspace.' },
+            { name: '--workspace <dir>', help: 'Workbench clone directory when not running from inside it.' },
             { name: '--json', help: 'Emit the machine-readable session payload.' },
         ],
         examples: ['orizu session start', 'orizu session start --project highlight/hip --json'],
     },
     {
         path: ['session', 'status'],
-        usage: 'orizu session status [--session <id> | --status active|ended] [--json]',
-        summary: 'Inspect one session by id, including run summaries, or list sessions for the attached workspace.',
+        usage: 'orizu session status [--session <id> | --status active|ended] [--workspace <dir>] [--json]',
+        summary: 'Inspect one session by id (including run summaries and, when run inside the workbench clone, the session branch with local ahead/behind vs origin), or list sessions for the attached workspace.',
         group: 'Sessions',
         options: [
             { name: '--session <id>', help: 'Resume by session id; does not require the original terminal.' },
             { name: '--status <status>', help: 'Filter attached-workspace sessions when --session is omitted.', choices: ['active', 'ended'] },
+            { name: '--workspace <dir>', help: 'Workbench clone directory when not running from inside it.' },
             { name: '--json', help: 'Emit the machine-readable session or session-list payload.' },
         ],
         examples: ['orizu session status --session sess_123 --json', 'orizu session status --status active'],
@@ -781,15 +783,18 @@ export const COMMAND_DOCS = [
     },
     {
         path: ['session', 'finish'],
-        usage: 'orizu session finish --session <id> [--project <team/project>] [--json]',
-        summary: 'Finish a hosted session branch: no changes deletes the branch; changes create a repo_merge promotion manifest to review and approve (no GitHub PR).',
+        usage: 'orizu session finish --session <id> [--project <team/project>] [--push [--message <text>]] [--workspace <dir>] [--json]',
+        summary: 'Finish a hosted session branch: no changes deletes the branch; changes create a repo_merge promotion manifest to review and approve (no GitHub PR). Warns when your local session-branch checkout has uncommitted/unpushed work; --push stages, commits, and pushes it first.',
         group: 'Sessions',
         options: [
             { name: '--session <id>', help: 'Session id whose branch to finish.', required: true },
             { name: '--project <team/project>', help: 'Project scope for the manifest when the session is not already project-scoped.' },
+            { name: '--push', help: 'Opt-in: stage, commit, and push local session-branch work before finishing (raw git stays the default workflow).' },
+            { name: '--message <text>', help: 'Commit message for --push (a default is used when omitted).' },
+            { name: '--workspace <dir>', help: 'Workbench clone directory when not running from inside it.' },
             { name: '--json', help: 'Emit the machine-readable outcome (no-changes or the created manifest).' },
         ],
-        examples: ['orizu session finish --session sess_123', 'orizu session finish --session sess_123 --project highlight/hip --json'],
+        examples: ['orizu session finish --session sess_123', 'orizu session finish --session sess_123 --push --message "tune judge prompt"'],
     },
     {
         path: ['run', 'start'],