@otto-code/protocol 0.8.19 → 0.9.2

package/dist/schedule/types.d.ts

@@ -46,6 +46,10 @@ export declare const ScheduleTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         systemPrompt: z.ZodOptional<z.ZodString>;
         mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"workflow">;
+    definitionId: z.ZodString;
+    projectRoot: z.ZodString;
 }, z.core.$strip>], "type">;
 export type ScheduleTarget = z.infer<typeof ScheduleTargetSchema>;
 export declare const ScheduleRunSchema: z.ZodObject<{
@@ -90,7 +94,19 @@ export declare const ScheduleRunSchema: z.ZodObject<{
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow">;
+        definitionId: z.ZodString;
+        projectRoot: z.ZodString;
     }, z.core.$strip>], "type">>;
+    workflow: z.ZodOptional<z.ZodObject<{
+        definitionId: z.ZodString;
+        title: z.ZodString;
+        kind: z.ZodString;
+        projectRoot: z.ZodString;
+        fingerprint: z.ZodString;
+        runId: z.ZodString;
+    }, z.core.$strip>>;
     agentId: z.ZodNullable<z.ZodGUID>;
     workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
     personalityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -144,6 +160,10 @@ export declare const StoredScheduleSchema: z.ZodObject<{
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow">;
+        definitionId: z.ZodString;
+        projectRoot: z.ZodString;
     }, z.core.$strip>], "type">;
     status: z.ZodEnum<{
         completed: "completed";
@@ -207,7 +227,19 @@ export declare const StoredScheduleSchema: z.ZodObject<{
                 systemPrompt: z.ZodOptional<z.ZodString>;
                 mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
             }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            type: z.ZodLiteral<"workflow">;
+            definitionId: z.ZodString;
+            projectRoot: z.ZodString;
         }, z.core.$strip>], "type">>;
+        workflow: z.ZodOptional<z.ZodObject<{
+            definitionId: z.ZodString;
+            title: z.ZodString;
+            kind: z.ZodString;
+            projectRoot: z.ZodString;
+            fingerprint: z.ZodString;
+            runId: z.ZodString;
+        }, z.core.$strip>>;
         agentId: z.ZodNullable<z.ZodGUID>;
         workspaceId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
         personalityName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
@@ -221,14 +253,14 @@ export type StoredSchedule = z.infer<typeof StoredScheduleSchema>;
 export declare const ScheduleSummarySchema: z.ZodObject<{
     prompt: z.ZodString;
     name: z.ZodNullable<z.ZodString>;
-    id: z.ZodString;
-    createdAt: z.ZodString;
-    updatedAt: z.ZodString;
     status: z.ZodEnum<{
         completed: "completed";
         active: "active";
         paused: "paused";
     }>;
+    id: z.ZodString;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
     expiresAt: z.ZodNullable<z.ZodString>;
     target: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"agent">;
@@ -262,6 +294,10 @@ export declare const ScheduleSummarySchema: z.ZodObject<{
             systemPrompt: z.ZodOptional<z.ZodString>;
             mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"workflow">;
+        definitionId: z.ZodString;
+        projectRoot: z.ZodString;
     }, z.core.$strip>], "type">;
     cadence: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodLiteral<"every">;
@@ -318,5 +354,13 @@ export interface UpdateScheduleInput {
 export interface ScheduleExecutionResult {
     agentId: string | null;
     output: string | null;
+    workflow?: {
+        definitionId: string;
+        title: string;
+        kind: string;
+        projectRoot: string;
+        fingerprint: string;
+        runId: string;
+    };
 }
 //# sourceMappingURL=types.d.ts.map

package/dist/schedule/types.js

@@ -61,6 +61,15 @@ export const ScheduleTargetSchema = z.discriminatedUnion("type", [
             mcpServers: z.record(z.string(), z.unknown()).optional(),
         }),
     }),
+    // A schedule names a durable saved Workflow definition, never a Workflow run
+    // and never a reconstructed prompt. `projectRoot` is the authority boundary:
+    // the daemon resolves the selected project's Workflow store immediately
+    // before launch and refuses a definition from any other project or host.
+    z.object({
+        type: z.literal("workflow"),
+        definitionId: z.string().trim().min(1),
+        projectRoot: z.string().trim().min(1),
+    }),
 ]);
 export const ScheduleRunSchema = z.object({
     id: z.string(),
@@ -73,6 +82,19 @@ export const ScheduleRunSchema = z.object({
     // future Workflow/artifact target adapters one compatibility-safe audit slot.
     // Optional because persisted runs before v0.9 do not carry it.
     target: ScheduleTargetSchema.optional(),
+    // Immutable result of resolving a saved Workflow target at fire time. The
+    // definition can change later; this record is the audit of what actually
+    // launched. Optional keeps historical agent schedule runs readable.
+    workflow: z
+        .object({
+        definitionId: z.string().min(1),
+        title: z.string().min(1),
+        kind: z.string().min(1),
+        projectRoot: z.string().min(1),
+        fingerprint: z.string().min(1),
+        runId: z.string().min(1),
+    })
+        .optional(),
     agentId: z.guid().nullable(),
     workspaceId: z.string().nullable().optional(),
     // Who actually executed this run - the resolved personality (if any),

package/dist/search/text-match.d.ts

@@ -15,6 +15,14 @@ export interface MatchScore {
 export interface MatchOptions {
     /** Omit or pass null to match exactly. `fuzzyPolicyForToken` picks a policy. */
     fuzzy?: FuzzyPolicy | null;
+    /**
+     * Match characters that appear in order but not adjacently, so `pasbab` finds
+     * `otto-babysit`. Defaults to on. Turn it off where a near miss has to read as
+     * no match at all: it widens far enough that most typos hit something, and a
+     * list that preselects its first row would then act on that row when the user
+     * presses Enter expecting nothing to happen.
+     */
+    subsequence?: boolean;
 }
 /**
  * How much a typo in one query token is forgiven. Short tokens get
@@ -28,6 +36,8 @@ export interface FuzzyPolicy {
 }
 export declare function fuzzyPolicyForToken(token: string): FuzzyPolicy | null;
 export declare function scoreMatch(query: string, text: string, options?: MatchOptions): MatchScore | null;
+/** Match a query against a complete displayed path, including its separators. */
+export declare function scorePathMatch(query: string, path: string): MatchScore | null;
 export interface MatchRange {
     start: number;
     length: number;
@@ -50,6 +60,12 @@ export interface TextFieldsOptions {
      * query mixes long words that can absorb an edit with short ones that cannot.
      */
     typoTolerant?: boolean;
+    /**
+     * See `MatchOptions.subsequence`. Applied per token, so turning it off means
+     * every token has to appear as a run of adjacent characters in some field —
+     * `lab des` still matches "Label as Design", `labdes` no longer does.
+     */
+    subsequence?: boolean;
 }
 export declare function scoreTextFields(query: string, fields: string[], options?: TextFieldsOptions): MatchScore | null;
 //# sourceMappingURL=text-match.d.ts.map

package/dist/search/text-match.js

@@ -168,12 +168,41 @@ export function scoreMatch(query, text, options = {}) {
     const t = text.toLowerCase();
     if (t === q)
         return { tier: TIER_EXACT, offset: 0 };
-    const exact = scoreSubstringMatch(q, t) ?? scoreSubsequenceMatch(q, t);
+    const substring = scoreSubstringMatch(q, t);
+    const exact = substring ?? (options.subsequence === false ? null : scoreSubsequenceMatch(q, t));
     if (exact)
         return exact;
     const fuzzy = options.fuzzy;
     return fuzzy ? scoreFuzzyMatch(q, t, fuzzy) : null;
 }
+function compactText(value) {
+    let compact = "";
+    const offsets = [];
+    for (let index = 0; index < value.length; index += 1) {
+        if (!/[a-z0-9]/i.test(value[index]))
+            continue;
+        compact += value[index].toLowerCase();
+        offsets.push(index);
+    }
+    return { value: compact, offsets };
+}
+/** Match a query against a complete displayed path, including its separators. */
+export function scorePathMatch(query, path) {
+    const direct = scoreMatch(query, path);
+    if (direct)
+        return direct;
+    const compactQuery = compactText(query);
+    const compactPath = compactText(path);
+    if (!compactQuery.value || !compactPath.value)
+        return null;
+    const compactScore = scoreMatch(compactQuery.value, compactPath.value);
+    if (!compactScore)
+        return null;
+    return {
+        ...compactScore,
+        offset: compactPath.offsets[compactScore.offset] ?? compactScore.offset,
+    };
+}
 function mergeAdjacentRanges(indices) {
     const ranges = [];
     for (const index of indices) {
@@ -246,7 +275,7 @@ export function scoreTextFields(query, fields, options = {}) {
         const fuzzy = options.typoTolerant ? fuzzyPolicyForToken(token) : null;
         let best = null;
         for (const field of fields) {
-            const score = scoreMatch(token, field, { fuzzy });
+            const score = scoreMatch(token, field, { fuzzy, subsequence: options.subsequence });
             if (score && (!best || compareMatchScores(score, best) < 0)) {
                 best = score;
             }

package/dist/suggested-tasks.d.ts

@@ -3,9 +3,9 @@ import { z } from "zod";
  * Otto suggested-task wire schemas: the tasks.suggested.* start and dismiss RPCs and the suggested-task payloads. Fork-only capability, so it owns its schemas; messages.ts re-exports them.
  */
 export declare const SuggestedTaskStateSchema: z.ZodEnum<{
+    dismissed: "dismissed";
     pending: "pending";
     started: "started";
-    dismissed: "dismissed";
 }>;
 export declare const SuggestedTaskInfoSchema: z.ZodObject<{
     taskId: z.ZodString;
@@ -14,9 +14,9 @@ export declare const SuggestedTaskInfoSchema: z.ZodObject<{
     tldr: z.ZodString;
     cwd: z.ZodOptional<z.ZodString>;
     state: z.ZodEnum<{
+        dismissed: "dismissed";
         pending: "pending";
         started: "started";
-        dismissed: "dismissed";
     }>;
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
@@ -32,9 +32,9 @@ export declare const SuggestedTasksChangedSchema: z.ZodObject<{
             tldr: z.ZodString;
             cwd: z.ZodOptional<z.ZodString>;
             state: z.ZodEnum<{
+                dismissed: "dismissed";
                 pending: "pending";
                 started: "started";
-                dismissed: "dismissed";
             }>;
             createdAt: z.ZodString;
             updatedAt: z.ZodString;
@@ -65,6 +65,10 @@ export declare const TasksSuggestedStartRequestMessageSchema: z.ZodObject<{
         subagent: "subagent";
         in_session: "in_session";
     }>;
+    launch: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strip>>;
     requestId: z.ZodString;
 }, z.core.$strip>;
 export declare const TasksSuggestedStartResponseMessageSchema: z.ZodObject<{

package/dist/suggested-tasks.js

@@ -62,6 +62,8 @@ export const TasksSuggestedStartRequestMessageSchema = z.object({
     parentAgentId: z.string(),
     taskIds: z.array(z.string()),
     mode: TasksSuggestedStartModeSchema,
+    // Omitted by older clients, which retain the source chat's configuration.
+    launch: z.object({ provider: z.string(), model: z.string() }).optional(),
     requestId: z.string(),
 });
 export const TasksSuggestedStartResponseMessageSchema = z.object({