@1yefuwang1/dsh-worktrees 0.0.0-stage → 0.2.13

package/dist/sessions.d.ts

@@ -0,0 +1,31 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { SessionSettings } from './types.js';
+export type { SessionSettings } from './types.js';
+export declare class SessionBootstrap {
+    private readonly owner;
+    private readonly handles;
+    constructor(owner: Context);
+    actor(id: string): Agent;
+    isLive(agent: Agent): boolean;
+    settings(agent: Agent, signal?: AbortSignal): Promise<SessionSettings>;
+    assertBlank(agent: Agent): Promise<void>;
+    create(input: {
+        cwd: string;
+        title: string;
+        source: Agent;
+        settings: SessionSettings;
+        mode: 'new' | 'continue';
+        signal?: AbortSignal;
+        onCreated?: (result: {
+            agent: Agent;
+            sessionId: string;
+            workspaceId: string;
+        }) => Promise<void>;
+    }): Promise<{
+        agent: Agent;
+        sessionId: string;
+        workspaceId: string;
+    }>;
+    close(): Promise<void>;
+}

package/dist/sessions.js

@@ -0,0 +1,130 @@
+import { randomUUID } from 'node:crypto';
+import { realpath, stat } from 'node:fs/promises';
+import { SessionId, SessionSeq, SessionLogOffset, buildForkSeed } from '@deepseek-ai/dsh-session';
+import { setSandboxMode } from '@deepseek-ai/dsh-sandbox-policy';
+import { setApprovalPolicy } from '@deepseek-ai/dsh-user-approval';
+import { hashValue } from './schema.js';
+import { WorktreeError } from './errors.js';
+import { capability, required, policyOf } from './runtime.js';
+export class SessionBootstrap {
+    owner;
+    handles = new Map();
+    constructor(owner) { this.owner = owner; }
+    actor(id) {
+        const agent = required(this.owner, 'agents').get(id);
+        if (agent === undefined)
+            throw new WorktreeError('SESSION_NOT_LIVE', 'The source session is no longer live. Open it and retry.');
+        if (agent.session.header.origin === 'subagent')
+            throw new WorktreeError('SUBAGENT_SOURCE', 'New top-level worktree conversations require an ordinary source session.');
+        return agent;
+    }
+    isLive(agent) { return required(this.owner, 'agents').get(agent.id) === agent; }
+    async settings(agent, signal) {
+        const query = required(this.owner, 'sessionQuery');
+        const observation = await query.observeSession(agent.id, { signal, projectionMode: 'all' });
+        try {
+            if (!this.isLive(agent))
+                throw new WorktreeError('SESSION_CHANGED', 'The source session generation changed.');
+            const values = observation.projections?.values;
+            const selection = values?.modelSelection;
+            const candidate = selection?.next ?? (agent.options.provider && agent.options.model ? {
+                provider: agent.options.provider, model: agent.options.model,
+                ...(agent.options.reasoningEffort === undefined ? {} : { reasoningEffort: String(agent.options.reasoningEffort) }),
+            } : null);
+            const model = candidate === null ? null : {
+                provider: candidate.provider, model: candidate.model,
+                ...(candidate.reasoningEffort === undefined ? {} : { reasoningEffort: candidate.reasoningEffort }),
+            };
+            if (model !== null && (typeof model.provider !== 'string' || typeof model.model !== 'string' || !model.provider || !model.model))
+                throw new WorktreeError('INVALID_MODEL', 'The source model selection is not valid. Select a model before preparing a worktree.');
+            const presetValue = values?.agentPreset ?? observation.header.agentPreset;
+            const preset = typeof presetValue === 'string' ? presetValue : null;
+            const approval = capability(agent.ctx, 'approval');
+            const policy = approval?.overrideOf(agent.session) ?? approval?.config.policy ?? 'ask';
+            const plan = capability(agent.ctx, 'planMode')?.get(agent);
+            const base = { model, preset, sandbox: policyOf(agent).mode, approval: policy, plan: plan?.pending ?? plan?.active ?? false };
+            return { ...base, hash: hashValue(base) };
+        }
+        finally {
+            observation[Symbol.dispose]();
+        }
+    }
+    async assertBlank(agent) {
+        if (!this.isLive(agent) || agent.status !== 'idle' || agent.inbox.nextStep.length > 0 || agent.inbox.nextTurn.length > 0)
+            throw new WorktreeError('SOURCE_BUSY', 'The source must remain an idle blank conversation without queued input.');
+        const observation = await required(this.owner, 'sessionQuery').observeSession(agent.id, { projectionMode: 'all' });
+        try {
+            if (observation.events.some(e => e.type === 'turn/start'))
+                throw new WorktreeError('SOURCE_STARTED', 'The source conversation has already started. Prepare another New Conversation instead.');
+            if (!this.isLive(agent) || agent.status !== 'idle' || agent.inbox.nextStep.length > 0 || agent.inbox.nextTurn.length > 0)
+                throw new WorktreeError('SOURCE_BUSY', 'The source changed while its blank state was checked.');
+        }
+        finally {
+            observation[Symbol.dispose]();
+        }
+    }
+    async create(input) {
+        const cwd = await realpath(input.cwd);
+        if (!(await stat(cwd)).isDirectory())
+            throw new WorktreeError('MISSING_PROJECT_DIRECTORY', 'The chosen remote tree does not contain the project directory.');
+        if (input.signal?.aborted)
+            throw new WorktreeError('CANCELLED', 'Session creation was cancelled.');
+        const workspace = await required(this.owner, 'workspaceRegistry').create(cwd, input.title);
+        if (workspace.path !== cwd)
+            throw new WorktreeError('WORKSPACE_IDENTITY', 'The canonical Workspace path does not match the execution directory.');
+        let options = {
+            sessionId: SessionId(randomUUID()),
+            meta: { cwd, ...(input.settings.preset === null ? {} : { agentPreset: input.settings.preset }) },
+            signal: input.signal,
+            agentOptions: input.settings.model === null ? {} : {
+                provider: input.settings.model.provider, model: input.settings.model.model,
+                ...(input.settings.model.reasoningEffort === undefined ? {} : { reasoningEffort: input.settings.model.reasoningEffort }),
+            },
+            setup: async (agentCtx, child) => {
+                const presets = capability(this.owner, 'agentPresets');
+                if (presets !== undefined) {
+                    const selected = await presets.resolve(input.settings.preset ?? undefined);
+                    await presets.mount(agentCtx, selected.id);
+                }
+                else if (input.settings.preset !== null)
+                    throw new WorktreeError('MISSING_PRESET_SERVICE', 'The source preset cannot be mounted in this profile.');
+                child.inbox.clear();
+                setSandboxMode(child.session, input.settings.sandbox);
+                setApprovalPolicy(child.session, input.settings.approval);
+                child.session.append('plan/mode', { active: input.settings.plan });
+                if (input.settings.model !== null)
+                    child.session.append('model/selection', input.settings.model);
+            },
+        };
+        if (input.mode === 'continue') {
+            const observation = await required(this.owner, 'sessionQuery').observeSession(input.source.id, { signal: input.signal, projectionMode: 'all' });
+            try {
+                let boundary = -1;
+                for (let i = 0; i < observation.events.length; i++)
+                    if (observation.events[i]?.type === 'turn/end')
+                        boundary = i;
+                if (boundary < 0)
+                    throw new WorktreeError('NO_COMPLETED_TURN', 'This conversation has no completed turn to inherit. Start a fresh conversation instead.');
+                if (observation.events[boundary]?.seq !== boundary)
+                    throw new WorktreeError('INVALID_FORK_BOUNDARY', 'The source log does not have a contiguous completed-turn boundary.');
+                options = { ...options, seed: buildForkSeed(observation.events, SessionSeq(boundary)), inheritedEventCount: SessionLogOffset(boundary + 1), meta: { ...options.meta, parentSession: input.source.id, isSeeded: true } };
+            }
+            finally {
+                observation[Symbol.dispose]();
+            }
+        }
+        const handle = await required(this.owner, 'agents').create(options);
+        this.handles.set(handle.agent.id, handle);
+        await input.onCreated?.({ agent: handle.agent, sessionId: handle.agent.id, workspaceId: workspace.id });
+        await workspace.attachSession(handle.agent.id);
+        const flushed = await required(this.owner, 'sessions').flush(handle.agent.session);
+        if (!flushed)
+            throw new WorktreeError('MISSING_DURABILITY_BARRIER', 'No persistence listener participated in the session durability checkpoint.');
+        return { agent: handle.agent, sessionId: handle.agent.id, workspaceId: workspace.id };
+    }
+    async close() {
+        const values = [...this.handles.values()];
+        this.handles.clear();
+        await Promise.allSettled(values.map(async (h) => { h.agent.cancel({ kind: 'disposed' }); await h.dispose(); await h.agent.whenIdle(); }));
+    }
+}

package/dist/store.d.ts

@@ -0,0 +1,114 @@
+import type { WorktreeRecord, OperationRecord } from './types.js';
+export declare const worktreeDomain: {
+    name: string;
+    version: number;
+    layout: "per-record";
+    tables: {
+        worktrees: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            operationId: string;
+            repoRoot: string;
+            commonDir: string;
+            projectSubdir: string;
+            checkoutRoot: string;
+            effectiveCwd: string;
+            remote: string;
+            remoteIdentity: string;
+            remoteBranch: string;
+            baseOid: string;
+            baseRef: string;
+            fetchedAt: number;
+            createdAt: number;
+            sessionIds: string[];
+            workspaceId: string | null;
+            branch: string | null;
+            protected: boolean;
+            archived: boolean;
+            state: "creating" | "ready" | "recovery-required" | "missing";
+            error: string | null;
+            displayName?: string | undefined;
+            naming?: {
+                title: string;
+                slug: string;
+                directoryName: string;
+                branch: string;
+                source: "model" | "fallback";
+                fallbackReason?: "disabled" | "unavailable" | "timeout" | "provider-failure" | "invalid-output" | "output-limit" | "incomplete-output" | undefined;
+            } | undefined;
+            projectId?: string | undefined;
+            folderId?: string | undefined;
+            firstMessageNaming?: {
+                sessionId: string;
+                initialBranch: string;
+                phase: "waiting" | "generating" | "generated" | "renaming" | "complete" | "skipped";
+                messageSeq?: number | undefined;
+                messageId?: string | undefined;
+                messageHash?: string | undefined;
+                generatedName?: {
+                    title: string;
+                    slug: string;
+                    directoryName: string;
+                    branch: string;
+                    source: "model" | "fallback";
+                    fallbackReason?: "disabled" | "unavailable" | "timeout" | "provider-failure" | "invalid-output" | "output-limit" | "incomplete-output" | undefined;
+                } | undefined;
+                reason?: string | undefined;
+            } | undefined;
+        }>;
+        operations: import("@deepseek-ai/dsh-storage-domain").DomainTableSpec<string, {
+            id: string;
+            kind: "create" | "handoff";
+            requestHash: string;
+            actorId: string;
+            worktreeId: string;
+            settingsHash: string;
+            sourceSessionId: string;
+            sessionMode: "new" | "continue";
+            workspaceId: string | null;
+            settings: {
+                model: {
+                    provider: string;
+                    model: string;
+                    reasoningEffort?: string | undefined;
+                } | null;
+                preset: string | null;
+                sandbox: "read-only" | "workspace-write" | "danger-full-access";
+                approval: "ask" | "never";
+                plan: boolean;
+                hash: string;
+            };
+            targetRoot: string | null;
+            previewId: string | null;
+            appliedHead: string | null;
+            appliedFingerprint: string | null;
+            phase: "fetching" | "ready" | "recovery-required" | "planned" | "checkout-created" | "session-created" | "applying" | "code-applied" | "cancel-requested" | "cancelled-before-effects";
+            createdAt: number;
+            updatedAt: number;
+            sessionId: string | null;
+            error: {
+                code: string;
+                message: string;
+            } | null;
+            generatedName?: {
+                title: string;
+                slug: string;
+                directoryName: string;
+                branch: string;
+                source: "model" | "fallback";
+                fallbackReason?: "disabled" | "unavailable" | "timeout" | "provider-failure" | "invalid-output" | "output-limit" | "incomplete-output" | undefined;
+            } | undefined;
+            namingStarted?: boolean | undefined;
+        }>;
+    };
+};
+export interface RecordTable<T> {
+    get(key: string): T | undefined;
+    entries(): IterableIterator<[string, T]>;
+    put(key: string, value: T): Promise<void>;
+    delete(key: string): Promise<boolean>;
+}
+export interface WorktreeStore {
+    worktrees: RecordTable<WorktreeRecord>;
+    operations: RecordTable<OperationRecord>;
+    close(): Promise<void>;
+}

package/dist/store.js

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+import { defineDomain, domainTable } from '@deepseek-ai/dsh-storage-domain';
+const str = z.string().max(4096);
+const namingSchema = z.object({
+    title: z.string().min(1).max(60), slug: z.string().min(1).max(40).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/u),
+    directoryName: z.string().min(10).max(49).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/u),
+    branch: z.string().min(19).max(58).regex(/^worktree\/[a-z0-9]+(?:-[a-z0-9]+)*-[0-9a-f]{8}$/u),
+    source: z.enum(['model', 'fallback']),
+    fallbackReason: z.enum(['disabled', 'unavailable', 'timeout', 'provider-failure', 'invalid-output', 'output-limit', 'incomplete-output']).optional(),
+}).strict();
+const worktreeSchema = z.object({
+    id: z.string().uuid(), operationId: z.string().uuid(), repoRoot: str, commonDir: str, projectSubdir: str,
+    checkoutRoot: str, effectiveCwd: str, remote: str, remoteIdentity: str, remoteBranch: str,
+    baseOid: str, baseRef: str, fetchedAt: z.number().int().nonnegative(), createdAt: z.number().int().nonnegative(),
+    sessionIds: z.array(str), workspaceId: str.nullable(), branch: str.nullable(), protected: z.boolean(), archived: z.boolean(),
+    state: z.enum(['creating', 'ready', 'recovery-required', 'missing']), error: str.nullable(),
+    displayName: z.string().min(1).max(60).optional(), naming: namingSchema.optional(),
+    projectId: z.string().uuid().optional(), folderId: z.string().min(1).max(256).optional(),
+    firstMessageNaming: z.object({
+        sessionId: str, initialBranch: str,
+        phase: z.enum(['waiting', 'generating', 'generated', 'renaming', 'complete', 'skipped']),
+        messageSeq: z.number().int().nonnegative().optional(), messageId: str.optional(),
+        messageHash: z.string().regex(/^[0-9a-f]{64}$/u).optional(), generatedName: namingSchema.optional(),
+        reason: z.string().max(128).optional(),
+    }).strict().optional(),
+}).strict();
+const settingsSchema = z.object({
+    model: z.object({ provider: str, model: str, reasoningEffort: str.optional() }).strict().nullable(),
+    preset: str.nullable(), sandbox: z.enum(['read-only', 'workspace-write', 'danger-full-access']),
+    approval: z.enum(['ask', 'never']), plan: z.boolean(), hash: str,
+}).strict();
+const operationSchema = z.object({
+    id: z.string().uuid(), kind: z.enum(['create', 'handoff']), requestHash: str, actorId: str, worktreeId: z.string().uuid(),
+    settingsHash: str, sourceSessionId: str, sessionMode: z.enum(['new', 'continue']), workspaceId: str.nullable(),
+    settings: settingsSchema, targetRoot: str.nullable(), previewId: str.nullable(), appliedHead: str.nullable(), appliedFingerprint: str.nullable(),
+    phase: z.enum(['planned', 'fetching', 'checkout-created', 'session-created', 'ready', 'applying', 'code-applied', 'cancel-requested', 'cancelled-before-effects', 'recovery-required']),
+    createdAt: z.number().int().nonnegative(), updatedAt: z.number().int().nonnegative(), sessionId: str.nullable(),
+    error: z.object({ code: str, message: str }).strict().nullable(),
+    generatedName: namingSchema.optional(), namingStarted: z.boolean().optional(),
+}).strict();
+export const worktreeDomain = defineDomain({
+    name: 'dsh_worktrees', version: 1, layout: 'per-record',
+    tables: { worktrees: domainTable(worktreeSchema), operations: domainTable(operationSchema) },
+});

package/dist/types.d.ts

@@ -0,0 +1,262 @@
+export interface WorktreeConfig {
+    root: string;
+    gitExecutable: string;
+    defaultRemote: string;
+    defaultBranch: string;
+    commandTimeoutMs: number;
+    fetchTimeoutMs: number;
+    operationTimeoutMs: number;
+    maxSnapshotBytes: number;
+    maxFiles: number;
+    maxRefBytes: number;
+    namingEnabled?: boolean;
+    namingProvider?: string;
+    namingModel?: string;
+    namingTimeoutMs?: number;
+    namingMaxTokens?: number;
+}
+export type NamingFallbackReason = 'disabled' | 'unavailable' | 'timeout' | 'provider-failure' | 'invalid-output' | 'output-limit' | 'incomplete-output';
+/** Safe, durable result of one auxiliary call; never stores task text or provider errors. */
+export interface GeneratedWorktreeName {
+    title: string;
+    slug: string;
+    directoryName: string;
+    branch: string;
+    source: 'model' | 'fallback';
+    fallbackReason?: NamingFallbackReason;
+}
+/** Git execution is injected; production uses the managed subprocess/sandbox capabilities. */
+export interface GitRunSpec {
+    cwd: string;
+    args: readonly string[];
+    env?: NodeJS.ProcessEnv;
+    stdin?: string | Uint8Array;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxBytes?: number;
+    /** Git's documented nonzero outcomes must be opted into per command. */
+    allowedExitCodes?: readonly number[];
+}
+export interface GitRunResult {
+    stdout: Buffer;
+    stderr: Buffer;
+    exitCode: number;
+}
+export type GitExecutor = (spec: GitRunSpec) => Promise<GitRunResult>;
+export interface RepositoryInfo {
+    root: string;
+    commonDir: string;
+    projectSubdir: string;
+    head: string;
+    branch: string | null;
+}
+export interface RemoteInfo {
+    name: string;
+    identity: string;
+}
+export interface RemoteBranch {
+    name: string;
+    oid: string;
+}
+export interface RemoteBranches {
+    remote: string;
+    remoteIdentity: string;
+    defaultBranch: string | null;
+    branches: RemoteBranch[];
+    observedAt: number;
+}
+export interface CheckoutState {
+    head: string;
+    branch: string | null;
+    dirty: boolean;
+    changes: number;
+    untracked: number;
+}
+/** Internal observation only; progress carries no caller authority or task data. */
+export type SetupProgressStage = 'fetching' | 'creating' | 'naming' | 'opening' | 'ready';
+export interface WorktreeSetupProgress {
+    readonly stage: SetupProgressStage;
+    readonly operationId: string;
+    readonly worktreeId?: string;
+}
+export interface CreateCheckoutInput {
+    id: string;
+    repository: RepositoryInfo;
+    destination: string;
+    remote: string;
+    remoteIdentity: string;
+    remoteBranch: string;
+    baseRef: string;
+    signal?: AbortSignal;
+    /** Observer failures are ignored; never used to authorize or change Git effects. */
+    onProgress?: (stage: 'fetching' | 'creating') => void;
+}
+export interface CreatedCheckout {
+    checkoutRoot: string;
+    effectiveCwd: string;
+    baseOid: string;
+    baseRef: string;
+    fetchedAt: number;
+}
+export interface PatchFile {
+    path: string;
+    status: string;
+    binary: boolean;
+}
+export interface WorktreePreview {
+    id: string;
+    worktreeId: string;
+    sourceSessionId: string;
+    sourceHead: string;
+    sourceFingerprint: string;
+    sourceRoot: string;
+    sourceCommonDir: string;
+    targetCommonDir: string;
+    finalTree: string;
+    snapshotRoot: string;
+    targetRoot: string;
+    targetHead: string;
+    baseOid: string;
+    patchPath: string;
+    patchHash: string;
+    bytes: number;
+    files: PatchFile[];
+    createdAt: number;
+}
+export interface SnapshotInput {
+    worktreeId: string;
+    sourceSessionId: string;
+    repositoryRoot: string;
+    checkoutRoot: string;
+    targetRoot: string;
+    baseOid: string;
+    snapshotRoot: string;
+    signal?: AbortSignal;
+}
+/** One durable, source-log-bound naming opportunity; task text stays only in the session log. */
+export interface FirstMessageNaming {
+    sessionId: string;
+    initialBranch: string;
+    phase: 'waiting' | 'generating' | 'generated' | 'renaming' | 'complete' | 'skipped';
+    messageSeq?: number;
+    messageId?: string;
+    messageHash?: string;
+    generatedName?: GeneratedWorktreeName;
+    reason?: string;
+}
+export interface WorktreeRecord {
+    id: string;
+    operationId: string;
+    repoRoot: string;
+    commonDir: string;
+    projectSubdir: string;
+    checkoutRoot: string;
+    effectiveCwd: string;
+    remote: string;
+    remoteIdentity: string;
+    remoteBranch: string;
+    baseOid: string;
+    baseRef: string;
+    fetchedAt: number;
+    createdAt: number;
+    sessionIds: string[];
+    workspaceId: string | null;
+    branch: string | null;
+    displayName?: string;
+    naming?: GeneratedWorktreeName;
+    firstMessageNaming?: FirstMessageNaming;
+    /** Logical project membership; execution cwd and native Workspace stay independent. */
+    projectId?: string;
+    folderId?: string;
+    protected: boolean;
+    archived: boolean;
+    state: 'creating' | 'ready' | 'recovery-required' | 'missing';
+    error: string | null;
+}
+export type OperationPhase = 'planned' | 'fetching' | 'checkout-created' | 'session-created' | 'ready' | 'applying' | 'code-applied' | 'cancel-requested' | 'cancelled-before-effects' | 'recovery-required';
+export interface SessionSettings {
+    model: {
+        provider: string;
+        model: string;
+        reasoningEffort?: string;
+    } | null;
+    preset: string | null;
+    sandbox: 'read-only' | 'workspace-write' | 'danger-full-access';
+    approval: 'ask' | 'never';
+    plan: boolean;
+    hash: string;
+}
+export interface OperationRecord {
+    id: string;
+    kind: 'create' | 'handoff';
+    requestHash: string;
+    actorId: string;
+    worktreeId: string;
+    settingsHash: string;
+    sourceSessionId: string;
+    sessionMode: 'new' | 'continue';
+    workspaceId: string | null;
+    settings: SessionSettings;
+    targetRoot: string | null;
+    previewId: string | null;
+    appliedHead: string | null;
+    appliedFingerprint: string | null;
+    generatedName?: GeneratedWorktreeName;
+    /** Durable checkout-first inference intent; interrupted creates never infer again. */
+    namingStarted?: boolean;
+    phase: OperationPhase;
+    createdAt: number;
+    updatedAt: number;
+    sessionId: string | null;
+    error: {
+        code: string;
+        message: string;
+    } | null;
+}
+export type WorktreeAction = 'list' | 'status' | 'branches' | 'create' | 'start' | 'branch' | 'protect' | 'preview' | 'export' | 'handoff' | 'archive';
+export interface WorktreeRequest {
+    action: WorktreeAction;
+    repoPath?: string;
+    id?: string;
+    operationId?: string;
+    remote?: string;
+    remoteIdentity?: string;
+    remoteBranch?: string;
+    sourceSessionId?: string;
+    sessionMode?: 'new' | 'continue';
+    requireBlankSource?: boolean;
+    settingsHash?: string;
+    firstPrompt?: string;
+    /** Pair on create; membership does not change execution or permission policy. */
+    projectId?: string;
+    folderId?: string;
+    name?: string;
+    protected?: boolean;
+    archived?: boolean;
+    previewId?: string;
+    targetPath?: string;
+    query?: string;
+    cursor?: string;
+    limit?: number;
+    includeArchived?: boolean;
+}
+export type CommandEnvelope = {
+    v: 1;
+    ok: true;
+    data: unknown;
+} | {
+    v: 1;
+    ok: false;
+    error: {
+        code: string;
+        message: string;
+    };
+};
+/** Result of create/start/handoff; clients must open this exact session identity. */
+export interface SessionResult {
+    worktree: WorktreeRecord;
+    sessionId: string;
+    workspaceId: string;
+    settingsHash: string;
+    operation: OperationRecord;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/icon.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 48 48"><g fill="none" stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"><path d="M14 11v26M14 25c0-10 20 0 20-14v-1"/><circle cx="14" cy="8" r="4"/><circle cx="14" cy="40" r="4"/><circle cx="34" cy="8" r="4"/></g></svg>

package/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Projects and worktrees",
+    "description": "Group Local and worktree threads in multi-folder projects, with visible checkout backing, fresh remote bases and guarded local handoff."
+  }
+}