@zivis/cli 0.1.0-alpha.5 → 0.1.0-alpha.52

package/dist/internal/target-auth/api-config.d.ts

@@ -1,14 +1,3 @@
-/**
- * Fetches an Application's auth config from the ZIVIS platform.
- *
- * Phase J.4: replaces the local `~/.config/zivis/target-configs/*.json`
- * file the user previously had to write by hand. The Application's IdP
- * discovery (clientId, domain, mode, scopes) lives on the Application
- * record on the platform; the CLI calls this endpoint to learn how to
- * PKCE-auth, then runs the flow locally and stores tokens in the user's
- * keychain. Tokens never leave the user's machine unless the user
- * explicitly ships them with a scenario-run trigger.
- */
 import type { TargetAuthConfig, WorkosMode } from "./types.js";
 interface AuthConfigResponse {
     applicationId: string;
@@ -27,11 +16,5 @@ interface AuthConfigResponse {
     error?: string;
 }
 export declare function fetchAuthConfig(applicationId: string, sessionName?: string): Promise<AuthConfigResponse>;
-/**
- * Adapt the platform's auth-config response into the local TargetAuthConfig
- * shape that the existing PKCE flow consumes. Throws when the application
- * isn't OAuth-PKCE-shaped (e.g., static_token, client_credentials) — the
- * caller should give a useful error and direct the user elsewhere.
- */
 export declare function adaptToWorkosConfig(resp: AuthConfigResponse): TargetAuthConfig;
 export {};

package/dist/internal/target-auth/api-config.js

@@ -1,14 +1,3 @@
-/**
- * Fetches an Application's auth config from the ZIVIS platform.
- *
- * Phase J.4: replaces the local `~/.config/zivis/target-configs/*.json`
- * file the user previously had to write by hand. The Application's IdP
- * discovery (clientId, domain, mode, scopes) lives on the Application
- * record on the platform; the CLI calls this endpoint to learn how to
- * PKCE-auth, then runs the flow locally and stores tokens in the user's
- * keychain. Tokens never leave the user's machine unless the user
- * explicitly ships them with a scenario-run trigger.
- */
 import { ApiClient } from "@zivis/mcp/api-client";
 import { DEFAULT_CONFIG } from "@zivis/mcp/types";
 export async function fetchAuthConfig(applicationId, sessionName) {
@@ -18,12 +7,6 @@ export async function fetchAuthConfig(applicationId, sessionName) {
     const client = new ApiClient(config);
     return client.request("GET", `/api/applications/${encodeURIComponent(applicationId)}/auth-config`);
 }
-/**
- * Adapt the platform's auth-config response into the local TargetAuthConfig
- * shape that the existing PKCE flow consumes. Throws when the application
- * isn't OAuth-PKCE-shaped (e.g., static_token, client_credentials) — the
- * caller should give a useful error and direct the user elsewhere.
- */
 export function adaptToWorkosConfig(resp) {
     if (!resp.oauth) {
         throw new Error(resp.hint || resp.error ||
@@ -37,4 +20,3 @@ export function adaptToWorkosConfig(resp) {
         extraScopes: resp.oauth.scopes,
     };
 }
-//# sourceMappingURL=api-config.js.map

package/dist/internal/target-auth/config.d.ts

@@ -1,15 +1,3 @@
-/**
- * Target-auth config storage (local-only, v1).
- *
- * Per-target IdP config (domain, client_id, mode, callback port) lives under
- * `~/.config/zivis/target-configs/<targetId>.json`. This is *config*, not
- * credentials — safe to commit a sanitized version to your repo if you want
- * teammates to share it.
- *
- * v2: ZIVIS will serve target-auth config from the API so any team member's
- * CLI can discover it. For now, configure once locally with `zivis target
- * configure` and check in the file if you want it shared.
- */
 import type { TargetAuthConfig } from "./types.js";
 export declare function loadTargetConfig(targetId: string): Promise<TargetAuthConfig | null>;
 export declare function saveTargetConfig(targetId: string, cfg: TargetAuthConfig): Promise<string>;

package/dist/internal/target-auth/config.js

@@ -1,15 +1,3 @@
-/**
- * Target-auth config storage (local-only, v1).
- *
- * Per-target IdP config (domain, client_id, mode, callback port) lives under
- * `~/.config/zivis/target-configs/<targetId>.json`. This is *config*, not
- * credentials — safe to commit a sanitized version to your repo if you want
- * teammates to share it.
- *
- * v2: ZIVIS will serve target-auth config from the API so any team member's
- * CLI can discover it. For now, configure once locally with `zivis target
- * configure` and check in the file if you want it shared.
- */
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import * as os from "node:os";
@@ -55,4 +43,3 @@ export async function listTargetConfigs() {
 export function getConfigPath(targetId) {
     return configPath(targetId);
 }
-//# sourceMappingURL=config.js.map

package/dist/internal/target-auth/index.d.ts

@@ -1,23 +1,5 @@
-/**
- * Target-auth orchestrator: load config, run the right IdP flow, manage tokens.
- *
- * Public API:
- *   getValidTargetToken(targetId, persona) — returns access_token; refreshes if near expiry
- *   loginTarget(targetId, persona)         — runs the appropriate IdP flow
- *   logoutTarget(targetId, persona)        — clears stored tokens
- *
- * Designed so RT-runner-side ephemeral cred plumbing only sees a flat
- * { accessToken, refreshToken?, expiresAt, idpType } bundle — no IdP
- * specifics leak past this boundary.
- */
 import type { EphemeralTargetCreds, TargetTokens } from "./types.js";
 export declare function loginTarget(targetId: string, persona: string): Promise<TargetTokens>;
-/**
- * J.4 path: log in against an Application by id. Auth config comes from
- * the platform (no local config file required). Tokens are stored under
- * the existing keychain namespace using applicationId as the key — same
- * keychain layout, no migration needed for already-stored tokens.
- */
 export declare function loginApplication(applicationId: string, persona: string, sessionName?: string): Promise<TargetTokens>;
 export declare function logoutTarget(targetId: string, persona: string): Promise<void>;
 export declare function getValidTargetToken(targetId: string, persona: string): Promise<TargetTokens | null>;

package/dist/internal/target-auth/index.js

@@ -1,15 +1,3 @@
-/**
- * Target-auth orchestrator: load config, run the right IdP flow, manage tokens.
- *
- * Public API:
- *   getValidTargetToken(targetId, persona) — returns access_token; refreshes if near expiry
- *   loginTarget(targetId, persona)         — runs the appropriate IdP flow
- *   logoutTarget(targetId, persona)        — clears stored tokens
- *
- * Designed so RT-runner-side ephemeral cred plumbing only sees a flat
- * { accessToken, refreshToken?, expiresAt, idpType } bundle — no IdP
- * specifics leak past this boundary.
- */
 import { loadTargetConfig } from "./config.js";
 import { loadTokens, storeTokens, deleteTokens } from "./keychain.js";
 import { loginWorkos, refreshWorkos } from "./workos.js";
@@ -21,12 +9,6 @@ export async function loginTarget(targetId, persona) {
     await storeTokens(targetId, persona, tokens);
     return tokens;
 }
-/**
- * J.4 path: log in against an Application by id. Auth config comes from
- * the platform (no local config file required). Tokens are stored under
- * the existing keychain namespace using applicationId as the key — same
- * keychain layout, no migration needed for already-stored tokens.
- */
 export async function loginApplication(applicationId, persona, sessionName) {
     const resp = await fetchAuthConfig(applicationId, sessionName);
     const cfg = adaptToWorkosConfig(resp);
@@ -98,4 +80,3 @@ async function runRefresh(cfg, refreshToken) {
             throw new Error(`Unsupported IdP type: ${cfg.type}`);
     }
 }
-//# sourceMappingURL=index.js.map

package/dist/internal/target-auth/keychain.d.ts

@@ -1,21 +1,3 @@
-/**
- * Target-auth keychain.
- *
- * Distinct namespace from the user's ZIVIS-platform tokens (handled by
- * `zivis-mcp-security`'s keychain module). A user can be logged into
- * ZIVIS itself AND to N customer-target IdPs simultaneously, each with
- * multiple personas (admin, user_a, …) for permutation testing.
- *
- * Storage layout
- *   service: zivis.target.<targetId>.<persona>
- *   account: zivis-target
- *   value:   JSON-serialised TargetTokens
- *
- * macOS-only for v1 (matches the engagement helper). Linux/Windows fall
- * back to an encrypted file on disk; the underlying impl lives in
- * `@zivis/mcp/auth/keychain.ts` for the platform login — we
- * deliberately don't share that module to keep the namespaces isolated.
- */
 import type { TargetTokens } from "./types.js";
 export declare function storeTokens(targetId: string, persona: string, tokens: TargetTokens): Promise<void>;
 export declare function loadTokens(targetId: string, persona: string): Promise<TargetTokens | null>;

package/dist/internal/target-auth/keychain.js

@@ -1,21 +1,3 @@
-/**
- * Target-auth keychain.
- *
- * Distinct namespace from the user's ZIVIS-platform tokens (handled by
- * `zivis-mcp-security`'s keychain module). A user can be logged into
- * ZIVIS itself AND to N customer-target IdPs simultaneously, each with
- * multiple personas (admin, user_a, …) for permutation testing.
- *
- * Storage layout
- *   service: zivis.target.<targetId>.<persona>
- *   account: zivis-target
- *   value:   JSON-serialised TargetTokens
- *
- * macOS-only for v1 (matches the engagement helper). Linux/Windows fall
- * back to an encrypted file on disk; the underlying impl lives in
- * `@zivis/mcp/auth/keychain.ts` for the platform login — we
- * deliberately don't share that module to keep the namespaces isolated.
- */
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 import * as fs from "node:fs/promises";
@@ -33,7 +15,6 @@ function fallbackPath(targetId, persona) {
     return path.join(dir, `${targetId}.${persona}.enc`);
 }
 function fallbackKey() {
-    // Same scheme as the platform-side keychain fallback: derive from username.
     return new Uint8Array(crypto.scryptSync(os.userInfo().username || "zivis", "zivis-target-salt", 32));
 }
 async function macStore(targetId, persona, value) {
@@ -42,7 +23,7 @@ async function macStore(targetId, persona, value) {
             "delete-generic-password", "-a", ACCOUNT, "-s", svc(targetId, persona),
         ]);
     }
-    catch { /* not present */ }
+    catch { }
     await execFileAsync("security", [
         "add-generic-password", "-a", ACCOUNT, "-s", svc(targetId, persona), "-w", value,
     ]);
@@ -64,7 +45,7 @@ async function macDelete(targetId, persona) {
             "delete-generic-password", "-a", ACCOUNT, "-s", svc(targetId, persona),
         ]);
     }
-    catch { /* not present */ }
+    catch { }
 }
 async function fileStore(targetId, persona, value) {
     const p = fallbackPath(targetId, persona);
@@ -105,7 +86,7 @@ async function fileDelete(targetId, persona) {
     try {
         await fs.unlink(fallbackPath(targetId, persona));
     }
-    catch { /* not present */ }
+    catch { }
 }
 async function tryMac() {
     if (process.platform !== "darwin")
@@ -147,4 +128,3 @@ export function getStorageName() {
         ? "macOS Keychain"
         : "encrypted file (~/.config/zivis/target-tokens)";
 }
-//# sourceMappingURL=keychain.js.map

package/dist/internal/target-auth/types.d.ts

@@ -1,51 +1,25 @@
-/**
- * Target-auth: PKCE auth flows against the *customer's* identity provider.
- *
- * The user authenticates locally against the target system's IdP. Tokens
- * stay in the user's OS keychain. When a scenario run is triggered, the
- * CLI ships a short-lived access token (and optionally a refresh token)
- * to the ZIVIS platform, which uses it for the duration of the run only.
- * ZIVIS never persists target-system credentials.
- */
 export type IdpType = "workos" | "auth0" | "apikey" | "none";
-/** WorkOS path layout — three observed flavors. */
 export type WorkosMode = "user_management" | "authkit" | "workos";
 export interface WorkosConfig {
     type: "workos";
-    /** WorkOS client_id (AuthKit application). */
     clientId: string;
-    /**
-     * Auth host. e.g. `api.workos.com` (user_management/legacy) or
-     * `<custom>.authkit.app` (custom AuthKit domain).
-     */
     domain: string;
-    /** Path layout flavor. Defaults to `user_management`. */
     mode?: WorkosMode;
-    /** localhost callback port for the PKCE redirect. Defaults to 5174. */
     callbackPort?: number;
-    /** Extra OAuth scopes beyond `openid profile email offline_access`. */
     extraScopes?: string[];
 }
 export type TargetAuthConfig = WorkosConfig;
 export interface TargetTokens {
-    /** OAuth access token. */
     access_token: string;
-    /** OAuth refresh token, if the IdP issued one. */
     refresh_token?: string;
-    /** Unix-ms expiry, derived from JWT exp claim or `expires_in`. */
     expires_at: number;
-    /** Optional id_token for client-side claim inspection. */
     id_token?: string;
-    /** When this token bundle was obtained (unix-ms). */
     obtained_at: number;
 }
-/** Bundle shipped to ZIVIS on `scenario run` — RT consumes ephemerally. */
 export interface EphemeralTargetCreds {
     idpType: IdpType;
     accessToken: string;
     refreshToken?: string;
-    /** Unix-ms expiry of the access token. */
     expiresAt: number;
-    /** Echo of the persona, useful for audit logs. */
     persona?: string;
 }

package/dist/internal/target-auth/types.js

@@ -1,11 +1 @@
-/**
- * Target-auth: PKCE auth flows against the *customer's* identity provider.
- *
- * The user authenticates locally against the target system's IdP. Tokens
- * stay in the user's OS keychain. When a scenario run is triggered, the
- * CLI ships a short-lived access token (and optionally a refresh token)
- * to the ZIVIS platform, which uses it for the duration of the run only.
- * ZIVIS never persists target-system credentials.
- */
 export {};
-//# sourceMappingURL=types.js.map

package/dist/internal/target-auth/workos.d.ts

@@ -1,18 +1,3 @@
-/**
- * WorkOS PKCE login + refresh against a *target* IdP.
- *
- * Adapted from `zivis-rt/specs/engagements/meshmesh-cred-threat-model/scripts/authkit-helper.mjs`,
- * which is itself adapted from `@zivis/mcp/src/auth/oauth.ts`. Three
- * known WorkOS flavors are supported:
- *   - user_management — api.workos.com/user_management/{authorize,authenticate}
- *   - authkit         — <custom>.authkit.app/oauth2/{authorize,token}
- *   - workos          — legacy auth.workos.com/{authorize,oauth/token}
- *
- * Why a copy and not a shared module: the platform-side login uses a fixed
- * client_id and our own AuthKit. Target login uses the *customer's* IdP
- * config, parameterized per target. Same primitives, different config
- * surface — keeping them separate avoids accidental cross-tenant token mixing.
- */
 import type { TargetTokens, WorkosConfig } from "./types.js";
 export declare function decodeJwtPayload(jwt: string): Record<string, unknown> | null;
 declare function refreshTokens(cfg: WorkosConfig, refreshToken: string): Promise<TargetTokens>;

package/dist/internal/target-auth/workos.js

@@ -1,18 +1,3 @@
-/**
- * WorkOS PKCE login + refresh against a *target* IdP.
- *
- * Adapted from `zivis-rt/specs/engagements/meshmesh-cred-threat-model/scripts/authkit-helper.mjs`,
- * which is itself adapted from `@zivis/mcp/src/auth/oauth.ts`. Three
- * known WorkOS flavors are supported:
- *   - user_management — api.workos.com/user_management/{authorize,authenticate}
- *   - authkit         — <custom>.authkit.app/oauth2/{authorize,token}
- *   - workos          — legacy auth.workos.com/{authorize,oauth/token}
- *
- * Why a copy and not a shared module: the platform-side login uses a fixed
- * client_id and our own AuthKit. Target login uses the *customer's* IdP
- * config, parameterized per target. Same primitives, different config
- * surface — keeping them separate avoids accidental cross-tenant token mixing.
- */
 import * as crypto from "node:crypto";
 import * as http from "node:http";
 import { execFile } from "node:child_process";
@@ -69,12 +54,20 @@ function tokensFromResponse(d, prevRefresh) {
         obtained_at: Date.now(),
     };
 }
+function escapeHtml(s) {
+    return s
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;")
+        .replace(/'/g, "&#39;");
+}
 function htmlPage(success, msg = "") {
     const title = success ? "Authenticated" : "Auth failed";
     const color = success ? "#00d4aa" : "#ff5252";
     return `<!DOCTYPE html><html><head><title>${title}</title></head>
 <body style="font-family:system-ui;text-align:center;padding:50px;background:#0f0f1a;color:#fff;">
-<h1 style="color:${color};">${title}</h1><p>${msg}</p>
+<h1 style="color:${color};">${title}</h1><p>${escapeHtml(msg)}</p>
 <p>You can close this window.</p><script>setTimeout(()=>window.close(),1500);</script>
 </body></html>`;
 }
@@ -185,7 +178,6 @@ export async function loginWorkos(cfg, persona) {
         await open(authUrl);
     }
     catch {
-        // open() can fail in headless envs — print the URL and let the user click.
         await execFileAsync("printf", [authUrl]).catch(() => { });
         process.stderr.write(`[zivis] open ${authUrl}\n`);
     }
@@ -193,4 +185,3 @@ export async function loginWorkos(cfg, persona) {
     return exchangeCode(cfg, code, verifier);
 }
 export { refreshTokens as refreshWorkos };
-//# sourceMappingURL=workos.js.map

package/dist/internal/test-scope.d.ts

@@ -0,0 +1,99 @@
+import { type DevXRunApi } from "./devx-run.js";
+import { type SecurityContextApi, type SecurityContextOutcome } from "./security-context.js";
+import type { PackRegistryClient, PackTestEntry } from "./packs/types.js";
+export interface TestRunDeps {
+    apiClient: DevXRunApi & SecurityContextApi;
+    registryClient: PackRegistryClient;
+}
+export interface StartTestRunParams {
+    applicationId: string;
+    scopeId?: string;
+    cwd: string;
+    cliVersion: string;
+    precomputedContext?: SecurityContextOutcome;
+}
+export interface ResolvedScopeSummary {
+    id: string;
+    label: string;
+    tests: PackTestEntry[];
+}
+export interface TestRunEnvelope {
+    run_id: string;
+    application: {
+        id: string;
+    };
+    connection: {
+        mode: "connected";
+    };
+    git: {
+        sha: string | null;
+        dirty: boolean | null;
+    };
+    methodology: {
+        pack: string;
+        version: string;
+        path: string;
+        scope?: {
+            id: string;
+            label: string;
+            path: string;
+        };
+    };
+    context: {
+        path: string;
+    };
+    scope: ResolvedScopeSummary | null;
+    requested_intent: {
+        scope: string;
+    } | null;
+    result_contract: {
+        schema_version: string;
+        complete_command: string;
+    };
+    agent_instructions: string[];
+}
+export interface StartTestRunResult {
+    envelope: TestRunEnvelope;
+    resolvedScope: ResolvedScopeSummary | null;
+    contextOutcome: SecurityContextOutcome;
+}
+export declare function startTestRun(deps: TestRunDeps, params: StartTestRunParams): Promise<StartTestRunResult>;
+export type ChangeRecommendationOutcome = {
+    kind: "no-prior-context";
+    contextOutcome: SecurityContextOutcome;
+} | {
+    kind: "sha-not-found";
+    sha: string;
+    contextOutcome: SecurityContextOutcome;
+} | {
+    kind: "up-to-date";
+    sha: string;
+} | {
+    kind: "no-scope-match";
+    sha: string;
+    changedFileCount: number;
+} | {
+    kind: "recommendation";
+    sha: string;
+    changedFileCount: number;
+    scopes: {
+        id: string;
+        label: string;
+    }[];
+    testIds: string[];
+};
+export declare function tryBuildChangeRecommendation(deps: TestRunDeps, params: {
+    applicationId: string;
+    cwd: string;
+    cliVersion: string;
+}): Promise<ChangeRecommendationOutcome>;
+export interface TestScopeListing {
+    pack: string;
+    version: string;
+    scopes: {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+}
+export declare function listTestScopes(registryClient: PackRegistryClient, cliVersion: string): Promise<TestScopeListing>;

package/dist/internal/test-scope.js

@@ -0,0 +1,101 @@
+import { readGitMetadata, getChangedFilesSince } from "./git.js";
+import { startDevXRun, DEVX_RUN_CONTRACT_VERSION } from "./devx-run.js";
+import { fetchSecurityContext } from "./security-context.js";
+import { resolveCompatiblePack, resolveScope, listAvailableScopes } from "./packs/resolve.js";
+import { writeRunWorkFile } from "./run-workdir.js";
+import { buildChangeRecommendation } from "./change-recommendation.js";
+function scopeContentPath(resolved, scopeId) {
+    const entry = resolved.scopes.find((s) => s.id === scopeId);
+    return entry ? `${resolved.cacheDir}/${entry.path}` : resolved.cacheDir;
+}
+function formatDeclaredTestCatalog(tests) {
+    return tests
+        .filter((t) => !t.deprecated)
+        .map((t) => `${t.id} — ${t.title}`)
+        .join("; ");
+}
+function buildAgentInstructions(resolvedScope) {
+    if (resolvedScope) {
+        const catalog = formatDeclaredTestCatalog(resolvedScope.tests);
+        return [
+            `Read the base methodology and the "${resolvedScope.label}" scope guidance at methodology.scope.path.`,
+            `Focus this review on the "${resolvedScope.label}" scope. Requested intent is scope=${resolvedScope.id} — this does not mean other areas were evaluated.`,
+            ...(catalog
+                ? [
+                    `This scope's declared test catalog: ${catalog}. When you emit observations[].test_id, use exactly one of these declared ids for the check you actually ran — never invent a slug from the prose. If none of them matches what you ran, do not fabricate a new id; describe it in coverage_note instead.`,
+                ]
+                : []),
+            `You may report incidental findings outside this scope if you actually find them, but keep result provenance honest: do not claim coverage you did not perform.`,
+            `Use your own repository understanding, shell, and tools to perform the review. When finished, complete the run using result_contract.complete_command.`,
+        ];
+    }
+    return [
+        `Read the methodology at methodology.path and perform a full, adaptive AppSec review — decide applicability yourself rather than mechanically executing every category.`,
+        `Each scope you apply declares its own stable, permanent test catalog (tests[] in the pack manifest, e.g. AUTH-001, UPLOAD-002 — see the scope's manifest entry). When you emit observations[].test_id, use the declared id for the check you actually ran — never invent a slug from the prose.`,
+        `Use your own repository understanding, shell, and tools to perform the review. When finished, complete the run using result_contract.complete_command.`,
+    ];
+}
+export async function startTestRun(deps, params) {
+    const [git, contextOutcome, resolvedPack] = await Promise.all([
+        readGitMetadata(params.cwd),
+        params.precomputedContext ?? fetchSecurityContext(deps.apiClient, params.applicationId),
+        resolveCompatiblePack("appsec", { registryClient: deps.registryClient, cliVersion: params.cliVersion }),
+    ]);
+    const scope = params.scopeId ? await resolveScope(resolvedPack, params.scopeId) : null;
+    const resolvedScope = scope ? { id: scope.id, label: scope.label, tests: scope.tests } : null;
+    const started = await startDevXRun(deps.apiClient, {
+        applicationId: params.applicationId,
+        runType: "test",
+        requestedIntent: resolvedScope ? { scope: resolvedScope.id } : undefined,
+        pack: { packId: resolvedPack.packId, packType: resolvedPack.packType, version: resolvedPack.version },
+        cwd: params.cwd,
+    });
+    const contextPath = writeRunWorkFile(params.cwd, started.runId, "context.json", contextOutcome);
+    const envelope = {
+        run_id: started.runId,
+        application: { id: params.applicationId },
+        connection: { mode: "connected" },
+        git: { sha: git.commitSha ?? null, dirty: git.dirty ?? null },
+        methodology: {
+            pack: resolvedPack.packType,
+            version: resolvedPack.version,
+            path: resolvedPack.basePath,
+            ...(resolvedScope ? { scope: { id: resolvedScope.id, label: resolvedScope.label, path: scopeContentPath(resolvedPack, resolvedScope.id) } } : {}),
+        },
+        context: { path: contextPath },
+        scope: resolvedScope,
+        requested_intent: resolvedScope ? { scope: resolvedScope.id } : null,
+        result_contract: {
+            schema_version: DEVX_RUN_CONTRACT_VERSION,
+            complete_command: `zivis run complete ${started.runId} --input <result.json> --json`,
+        },
+        agent_instructions: buildAgentInstructions(resolvedScope),
+    };
+    return { envelope, resolvedScope, contextOutcome };
+}
+export async function tryBuildChangeRecommendation(deps, params) {
+    const contextOutcome = await fetchSecurityContext(deps.apiClient, params.applicationId);
+    const sha = contextOutcome.available ? contextOutcome.context.lastTestedGitSha : null;
+    if (!sha)
+        return { kind: "no-prior-context", contextOutcome };
+    const changedFiles = await getChangedFilesSince(params.cwd, sha);
+    if (changedFiles === undefined)
+        return { kind: "sha-not-found", sha, contextOutcome };
+    if (changedFiles.length === 0)
+        return { kind: "up-to-date", sha };
+    const resolvedPack = await resolveCompatiblePack("appsec", { registryClient: deps.registryClient, cliVersion: params.cliVersion });
+    const recommendation = buildChangeRecommendation(changedFiles, resolvedPack.scopes);
+    if (!recommendation)
+        return { kind: "no-scope-match", sha, changedFileCount: changedFiles.length };
+    const scopesById = new Map(resolvedPack.scopes.map((s) => [s.id, s]));
+    const scopes = recommendation.scopeIds.map((id) => ({ id, label: scopesById.get(id).label }));
+    return { kind: "recommendation", sha, changedFileCount: changedFiles.length, scopes, testIds: recommendation.testIds };
+}
+export async function listTestScopes(registryClient, cliVersion) {
+    const resolvedPack = await resolveCompatiblePack("appsec", { registryClient, cliVersion });
+    return {
+        pack: resolvedPack.packType,
+        version: resolvedPack.version,
+        scopes: listAvailableScopes(resolvedPack),
+    };
+}

package/dist/internal/threatmodel-run-state.d.ts

@@ -0,0 +1,15 @@
+export declare const THREATMODEL_RUN_STATE_FILENAME = "threatmodel-run.json";
+export interface ThreatModelRunState {
+    runId: string;
+    runType: "threatmodel";
+    applicationId: string;
+    startedAt: string;
+    status: "pending" | "completed";
+    packId: string;
+    packType: string;
+    packVersion: string;
+}
+export declare function recordThreatModelRunState(cwd: string, state: ThreatModelRunState): string;
+export declare function loadThreatModelRunState(cwd: string, runId: string): ThreatModelRunState | null;
+export declare function markThreatModelRunCompleted(cwd: string, runId: string): void;
+export declare function findActiveThreatModelRun(cwd: string): ThreatModelRunState | null;

package/dist/internal/threatmodel-run-state.js

@@ -0,0 +1,43 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { writeRunWorkFile } from "./run-workdir.js";
+export const THREATMODEL_RUN_STATE_FILENAME = "threatmodel-run.json";
+export function recordThreatModelRunState(cwd, state) {
+    return writeRunWorkFile(cwd, state.runId, THREATMODEL_RUN_STATE_FILENAME, state);
+}
+function runStatePath(cwd, runId) {
+    return path.join(cwd, ".zivis", "work", runId, THREATMODEL_RUN_STATE_FILENAME);
+}
+export function loadThreatModelRunState(cwd, runId) {
+    const filePath = runStatePath(cwd, runId);
+    if (!fs.existsSync(filePath))
+        return null;
+    try {
+        return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function markThreatModelRunCompleted(cwd, runId) {
+    const filePath = runStatePath(cwd, runId);
+    const existing = loadThreatModelRunState(cwd, runId);
+    if (!existing)
+        return;
+    fs.writeFileSync(filePath, JSON.stringify({ ...existing, status: "completed" }, null, 2) + "\n");
+}
+export function findActiveThreatModelRun(cwd) {
+    const workDir = path.join(cwd, ".zivis", "work");
+    if (!fs.existsSync(workDir))
+        return null;
+    const candidates = [];
+    for (const runId of fs.readdirSync(workDir)) {
+        const state = loadThreatModelRunState(cwd, runId);
+        if (state && state.status === "pending")
+            candidates.push(state);
+    }
+    if (candidates.length === 0)
+        return null;
+    candidates.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
+    return candidates[0];
+}