@frontera-sdk/cli 1.52.44 → 1.52.46

package/src/local/local-request-evidence.ts

@@ -16,7 +16,7 @@ export interface EvalsDetail {
   gated: number
   passed: number
   failed: number
-  newlyFailing: Array<{ name: string; file: string; reason: string | null }>
+  newlyFailing: Array<{ name: string; file: string; reason: string | null; environment?: string }>
   /**
    * Cases that couldn't run (the model provider refused them, the runtime did
    * not answer): evidence with any is not attached, since none newly failing
@@ -30,6 +30,8 @@ export interface EvalsDetail {
   baselinePassRate: number | null
   efficiency: { latencyMs: number | null; toolCalls: number | null; baseline: { latencyMs: number | null; toolCalls: number | null } | null }
   judged: { ran: boolean; reason: string | null }
+  /** With `--repeat`: how many times each case ran, and the cases that passed some runs and failed others. */
+  repeat?: { runs: number; flaky: string[] }
   ranAt: string
   /** Where they ran. */
   runtime: string
@@ -46,16 +48,39 @@ const mean = (values: Array<number | undefined>): number | null => {
  * (newly failing cases), the pass rate either side, and efficiency per case,
  * which is reported and never gates.
  */
-export function evalsDetail(input: { files: CaseFile[]; results: CaseResult[]; baseline: LastRun; runtime: string; now?: Date }): EvalsDetail {
+/**
+ * Why a case that failed here may pass in the workspace (X2, T12 step 2): it
+ * called a stand-in Plugin, which answers "not connected" on the local
+ * runtime and is the real connection in the target. Still a failure; the
+ * label says where it comes from.
+ */
+export function environmentOnly(result: Pick<CaseResult, 'toolNames'>, standIns: readonly string[]): string | null {
+  const used = standIns.filter((install) => (result.toolNames ?? []).some((t) => t.startsWith(`mcp__${install}__`)))
+  return used.length ? `local environment: ${used.join(', ')} ${used.length === 1 ? 'is a stand-in' : 'are stand-ins'} here (present in the target)` : null
+}
+
+/** The stand-in Plugins the project declares (`mcp/<install>.stand-in.json`), by install name. */
+export function standInInstalls(root: string): string[] {
+  const dir = join(root, 'mcp')
+  return existsSync(dir) ? readdirSync(dir).filter((f) => f.endsWith('.stand-in.json')).map((f) => f.slice(0, -'.stand-in.json'.length)).sort() : []
+}
+
+export function evalsDetail(input: { files: CaseFile[]; results: CaseResult[]; baseline: LastRun; runtime: string; now?: Date; standIns?: readonly string[] }): EvalsDetail {
   const { results, baseline } = input
   const compared = compareWithLastRun(results, baseline)
   const before = results.map((r) => baseline[caseKey(r)]).filter((b) => b !== undefined)
   const judgedCases = input.files.some((f) => f.cases.some((c) => c.judged?.length))
+  // Judged expectations are graded by the runtime's judge (X1); when it couldn't grade some, that is said.
+  const ungraded = results.filter((r) => r.judgedNotGraded)
+  const runs = Math.max(1, ...results.map((r) => r.repeat?.runs ?? 1))
   return {
     gated: results.length,
     passed: results.filter((r) => r.passed).length,
     failed: results.filter((r) => !r.passed && !r.notRun).length,
-    newlyFailing: compared.newlyFailing.map((r) => ({ name: r.name, file: r.file, reason: r.reason ?? null })),
+    newlyFailing: compared.newlyFailing.map((r) => {
+      const environment = environmentOnly(r, input.standIns ?? [])
+      return { name: r.name, file: r.file, reason: r.reason ?? null, ...(environment ? { environment } : {}) }
+    }),
     couldNotRun: compared.couldNotRun.map((r) => ({ name: r.name, what: r.notRun!.what, fix: r.notRun!.fix })),
     fixed: compared.fixed.map((r) => r.name),
     stillFailing: compared.stillFailing.map((r) => r.name),
@@ -67,8 +92,12 @@ export function evalsDetail(input: { files: CaseFile[]; results: CaseResult[]; b
       toolCalls: mean(results.map((r) => r.toolCalls)),
       baseline: before.length ? { latencyMs: mean(before.map((b) => b!.ms)), toolCalls: mean(before.map((b) => b!.toolCalls)) } : null,
     },
-    // Judged expectations are graded by the platform's judge model; a local run grades the rest.
-    judged: { ran: false, reason: judgedCases ? 'judged expectations are graded on the platform, with its judge model' : null },
+    judged: !judgedCases
+      ? { ran: false, reason: null }
+      : ungraded.length
+        ? { ran: false, reason: `the local runtime didn't grade ${ungraded.length} case${ungraded.length === 1 ? '’s' : 's’'} judged expectations: ${ungraded[0]!.judgedNotGraded}` }
+        : { ran: true, reason: null },
+    ...(runs > 1 ? { repeat: { runs, flaky: results.filter((r) => r.repeat?.flaky).map((r) => r.name) } } : {}),
     ranAt: (input.now ?? new Date()).toISOString(),
     runtime: input.runtime,
   }
@@ -79,7 +108,7 @@ export function evalsLine(title: string, d: EvalsDetail): string {
   if (!d.gated) return `${title}: no gated cases (mark the ones that guard it with gate: true)`
   if (d.couldNotRun.length) return `${title}: ${d.couldNotRun.length} of ${d.gated} gated case${d.gated === 1 ? '' : 's'} couldn’t run: ${[...new Set(d.couldNotRun.map((c) => c.what))].join('; ')}; ${d.couldNotRun[0]!.fix}`
   const rate = d.passRate === null ? '' : `, ${Math.round(d.passRate * 100)}% pass${d.baselinePassRate === null ? '' : ` (was ${Math.round(d.baselinePassRate * 100)}%)`}`
-  return `${title}: ${d.gated} gated case${d.gated === 1 ? '' : 's'}, ${d.newlyFailing.length ? `${d.newlyFailing.length} newly failing (${d.newlyFailing.map((c) => c.name).join(', ')})` : 'none newly failing'}${rate}`
+  return `${title}: ${d.gated} gated case${d.gated === 1 ? '' : 's'}, ${d.newlyFailing.length ? `${d.newlyFailing.length} newly failing (${d.newlyFailing.map((c) => (c.environment ? `${c.name}: ${c.environment}` : c.name)).join(', ')})` : 'none newly failing'}${rate}`
 }
 
 /** The newest pictures a session saved (`.frontera/evidence/<session>/`), newest first, at most `limit`. */

package/src/local/local-runtime-history.ts

@@ -13,12 +13,13 @@ import type { LocalProject } from './local-project'
  */
 
 export interface RuntimeRecord {
-  event: 'started' | 'stopped' | 'failed'
+  /** `jobs-restarted`: the jobs engine alone was restarted (by `local restart jobs`, or the supervisor when it stopped answering). */
+  event: 'started' | 'stopped' | 'failed' | 'jobs-restarted'
   /** When it happened: a start when the runtime was ready, a stop when it had stopped. */
   at: string
   /** A start: when it began starting, so its duration can be said. */
   since?: string
-  /** A failed start: which part, and why. */
+  /** A failed start: which part, and why. A jobs restart: why, and the runs it lost. */
   detail?: string
 }
 
@@ -32,7 +33,7 @@ export function readRuntimeHistory(stateDir: string): RuntimeRecord[] {
   try {
     const list = JSON.parse(readFileSync(historyPath(stateDir), 'utf8')) as unknown
     return Array.isArray(list)
-      ? list.filter((r): r is RuntimeRecord => !!r && typeof (r as RuntimeRecord).at === 'string' && ['started', 'stopped', 'failed'].includes((r as RuntimeRecord).event))
+      ? list.filter((r): r is RuntimeRecord => !!r && typeof (r as RuntimeRecord).at === 'string' && ['started', 'stopped', 'failed', 'jobs-restarted'].includes((r as RuntimeRecord).event))
       : []
   } catch {
     return []

package/src/local/local-said-once.ts

@@ -0,0 +1,51 @@
+import { createHash } from 'node:crypto'
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { writeFileAtomic } from '../fs-atomic'
+import type { LocalProject } from './local-project'
+
+/**
+ * Lists `local dev` says on every apply, said in full once per runtime start
+ * and as one line after that while they stay the same (Forge improvement
+ * plan N9): the settings that differ from the workspace, the failures the
+ * pull brought. In one build the same 8-line settings list and the same
+ * unfixable failure were printed on each of about 30 applies.
+ *
+ * Kept in `.frontera/local/said.json`: each list's digest and when it was
+ * last said in full.
+ */
+
+type Said = Record<string, { digest: string; at: string }>
+
+function path(project: LocalProject): string {
+  return join(project.stateDir, 'said.json')
+}
+
+function read(project: LocalProject): Said {
+  try {
+    const parsed = JSON.parse(readFileSync(path(project), 'utf8')) as unknown
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? (parsed as Said) : {}
+  } catch {
+    return {}
+  }
+}
+
+/**
+ * Whether to say this list in full: it changed since it was last said, or
+ * was last said before `since` (the runtime's start). Recorded when it is.
+ * Never throws: a lost record only means the list is said in full again.
+ */
+export function sayInFull(project: LocalProject, key: string, lines: readonly string[], since: string | undefined, now = new Date()): boolean {
+  const digest = createHash('sha256').update(lines.join('\n')).digest('hex').slice(0, 16)
+  const said = read(project)
+  const last = said[key]
+  const stale = !last || last.digest !== digest || (since !== undefined && Date.parse(last.at) < Date.parse(since))
+  if (!stale) return false
+  try {
+    writeFileAtomic(path(project), `${JSON.stringify({ ...said, [key]: { digest, at: now.toISOString() } }, null, 2)}\n`, 0o644)
+  } catch {
+    // Said in full again next time.
+  }
+  return true
+}

package/src/local/local-scaffold.ts

@@ -449,8 +449,26 @@ the cases that guard an Agent's behavior \`gate: true\`, and run them with
 you take are saved under \`.frontera/evidence/<session>/\`, where the
 person can attach them to the request.
 
-You cannot promote a deployment, apply a change request or read secrets.
-Say what is ready and let the person decide.
+Check every page (an App, a widget, the website it is embedded on) with the
+frontera MCP's \`browser_*\` tools, not another browser plugin: they share the
+project's tabs and sign-ins, and the person watches them in Forge.
+
+You cannot promote a deployment, apply a change request, decide for an
+Action, grant or read secrets. Prepare each such step for the person
+instead: the MCP tool \`person_step\` (or \`frontera local steps add\`)
+records the command, why it is needed, what it changes and the credential
+it needs, and Forge shows the delivery's steps as one card the person runs
+from. Prepare them all at once, in order, and never ask the person to paste
+a key, token or command output into the chat.
+
+The person may write while you work. Acknowledge each such message in your
+next visible text: say you have it, and whether you act on it now or after
+the step you are on; never let one go unanswered. When what is left is only
+the person's (steps you prepared, a decision, an answer to an open
+question), stop: end with \`Blocked on you:\` and each open item with its
+evidence (the step on the delivery card, what you verified and how). Do not
+retry what only the person can do, and do not call the work done while
+those items are open.
 
 The guides describe the product and its concepts, mostly through its
 screens. The exact format of each file is a JSON Schema for the release the
@@ -562,6 +580,8 @@ export function migrateMcpConfigs(root: string): string[] {
 
 const GITIGNORE = `node_modules/
 .env
+# A separate browser plugin's output (screenshots of other sites included); the frontera browser keeps its own under .frontera/.
+.playwright-mcp/
 `
 
 /**
@@ -604,6 +624,24 @@ function sampleFiles(name: string, agentModel?: string): Record<string, string>
   }
 }
 
+/**
+ * A new Agent's files, as the sample Agent's (L8, `frontera local new
+ * agent`): its agent.json with the name, description and model given, its
+ * bindings.json and a starter case. Behavior settings (operating.json) only
+ * for an Agent that serves customers: an internal Agent carries none.
+ */
+export function starterAgentFiles(slug: string, opts: { name: string; description?: string; model?: string; customer?: boolean }): Record<string, string> {
+  const agent = JSON.parse(AGENT('', opts.model)) as { config: Record<string, unknown> }
+  agent.config.name = opts.name
+  agent.config.description = opts.description ?? null
+  return {
+    [`agents/${slug}/agent.json`]: `${JSON.stringify(agent, null, 2)}\n`,
+    [`agents/${slug}/bindings.json`]: BINDINGS,
+    [`agents/${slug}/evals/regression.yaml`]: EVALS.replace('for the assistant', `for ${opts.name}`),
+    ...(opts.customer ? { [`agents/${slug}/operating.json`]: OPERATING } : {}),
+  }
+}
+
 /** The sample Agent as compared: its model and the project's name in its description are set per project. */
 function sampleAgent(text: string): unknown {
   try {

package/src/local/local-schemas.ts

@@ -33,6 +33,7 @@ export const SCHEMA_KINDS = [
   'bindings',
   'theme',
   'chat-app',
+  'app',
   'knowledge',
   'skill',
   'blueprint-object-type',
@@ -58,6 +59,7 @@ export const SCHEMA_FILES: Record<SchemaKind, string> = {
   bindings: 'agents/<slug>/bindings.json',
   theme: 'themes/<name>/theme.json',
   'chat-app': 'chat-apps/<slug>.json',
+  app: 'apps/<slug>.json',
   knowledge: 'knowledge/<name>/knowledge.json',
   skill: 'skills/<name>/SKILL.md (its front matter)',
   secrets: 'secrets.json',
@@ -76,13 +78,17 @@ type JsonSchema = Record<string, unknown>
  * One check on a case's last reply, by its `type` (`runCheck` in `local-test-runner.ts`).
  * Open to other keys: a check pulled from the platform may carry the platform's own.
  */
-function CHECK(type: 'contains' | 'regex' | 'tool_called' | 'tool_not_called'): JsonSchema {
+/** Which turn a check reads (L3): a person turn's number from 1, `last`, `any` or `all`. */
+const TURN = (what: string) => ({ anyOf: [{ type: 'integer', minimum: 1 }, { enum: ['last', 'any', 'all'] }], description: what })
+const REPLY_TURN = TURN('Which reply the check reads: the last (the default), turn n (a person turn’s number from 1), `any` (one turn’s reply passes) or `all` (every turn’s passes). A turn the case didn’t reach fails the check.')
+
+function CHECK(type: 'contains' | 'not_contains' | 'regex' | 'tool_called' | 'tool_not_called'): JsonSchema {
   const text = { type: 'string', description: 'What the check means, in words; shown when it fails.' }
-  if (type === 'contains') {
+  if (type === 'contains' || type === 'not_contains') {
     return {
-      title: 'contains',
+      title: type,
       type: 'object',
-      properties: { type: { const: 'contains' }, value: { type: 'string', minLength: 1, description: 'The phrase the reply must hold, ignoring case. Text: quote a number (`"12"`).' }, text },
+      properties: { type: { const: type }, value: { type: 'string', minLength: 1, description: type === 'contains' ? 'The phrase the reply must hold, ignoring case. Text: quote a number (`"12"`).' : 'A phrase the reply must not hold, ignoring case.' }, text, turn: REPLY_TURN },
       required: ['type', 'value'],
     }
   }
@@ -92,9 +98,10 @@ function CHECK(type: 'contains' | 'regex' | 'tool_called' | 'tool_not_called'):
       type: 'object',
       properties: {
         type: { const: 'regex' },
-        value: { type: 'string', minLength: 1, maxLength: 500, description: 'The pattern the reply must match (JavaScript syntax); a nested quantifier such as `(a+)+` is refused.' },
+        value: { type: 'string', minLength: 1, maxLength: 500, description: 'The pattern the reply must match: a JavaScript regular expression (ECMAScript, as `new RegExp(value, flags)` reads it), at most 500 characters, searched for anywhere in the first 20,000 characters of the reply. A group that is itself quantified, such as `(a+)+`, is refused, here and on the platform. Lookbehind, named groups and `\\b` work; a negative lookahead that never matches passes every reply, so test it against a passing and a failing reply.' },
         flags: { type: 'string', pattern: '^[dgimsuvy]*$', description: 'Regex flags; `i` when absent.' },
         text,
+        turn: REPLY_TURN,
       },
       required: ['type', 'value'],
     }
@@ -105,8 +112,8 @@ function CHECK(type: 'contains' | 'regex' | 'tool_called' | 'tool_not_called'):
     properties: {
       type: { const: type },
       tool: { type: 'string', minLength: 1, description: 'The tool’s name as the trace shows it (`function_<slug>` for a Function, `searchKnowledge`; a Plugin’s tool by its capability name, `mcp__…`, never its bare name).' },
-      argsSubset: { type: 'object', description: 'The arguments the call must carry.' },
-      turn: { enum: ['all', 'last'], description: 'Which turns’ calls the check reads: every turn of the case (`all`, the default) or only the last one, the turn whose reply the case grades.' },
+      argsSubset: { type: 'object', description: 'The arguments the call must carry. `{ absent: true }` as a value says the call must not carry that argument (`phone: { absent: true }`; an empty value counts as not there).' },
+      turn: TURN('Which turns’ calls the check reads: every turn of the case (`all`, the default, or `any`), only the last one (the turn whose reply the case grades), or turn n.'),
       mode: { enum: ['exact', 'ignore', 'subset', 'superset'], description: 'How argsSubset is compared; superset when absent. The `action` narration an Agent may add to any call is left out of the comparison unless argsSubset names it.' },
       text,
     },
@@ -134,7 +141,7 @@ const EVALS_SCHEMA: JsonSchema = {
           conversation: {
             type: 'array',
             minItems: 1,
-            description: 'One turn per item. Only the user turns are sent, in order, each as soon as the reply before it ends; an assistant turn is kept for whoever reads the case. `waitSeconds` on a user turn keeps a gap before it (`- { user: "Still there?", waitSeconds: 60 }` sends it a minute after the reply before). A case of more than one turn runs on this computer only: the workspace\'s evaluation datasets hold single questions, so `frontera local sync push` proposes the file\'s single-question cases and keeps the rest here.',
+            description: 'One turn per item. Only the user turns are sent, in order, each as soon as the reply before it ends; an assistant turn is kept for whoever reads the case. `waitSeconds` on a user turn keeps a gap before it (`- { user: "Still there?", waitSeconds: 60 }` sends it a minute after the reply before). A case of more than one turn goes to a workspace whose evaluation datasets hold conversations, whose runner sends each user turn as soon as the reply before it ends; one with `waitSeconds` runs on this computer only, and an older workspace, which holds single questions, gets only the single-question cases.',
             items: {
               type: 'object',
               properties: {
@@ -164,12 +171,18 @@ const EVALS_SCHEMA: JsonSchema = {
             items: { type: 'string', minLength: 1 },
             description: 'Phrases the last reply must contain, ignoring case. When present, expected is not checked.',
           },
+          notContains: {
+            type: 'array',
+            minItems: 1,
+            items: { type: 'string', minLength: 1 },
+            description: 'Phrases the last reply must not contain, ignoring case: what the Agent must never say. A check of type not_contains with a `turn` reads another reply.',
+          },
           checks: {
             type: 'array',
             description: 'Checks on the last reply and the tools the Agent called, graded as the platform grades them; every one must pass. `type` says which keys a check takes.',
-            items: { oneOf: [CHECK('contains'), CHECK('regex'), CHECK('tool_called'), CHECK('tool_not_called')] },
+            items: { oneOf: [CHECK('contains'), CHECK('not_contains'), CHECK('regex'), CHECK('tool_called'), CHECK('tool_not_called')] },
           },
-          judged: { type: 'array', items: { type: 'string' }, description: 'Expectations only the platform’s judge grades; kept, not graded locally.' },
+          judged: { type: 'array', items: { type: 'string' }, description: 'Expectations in words, graded by a judge model once the case’s other checks pass: on the platform by its judge, locally by the expectation judge on the grading model (`frontera local model-default <model> --for tests`).' },
           gold: { type: 'boolean', description: 'Human-certified on the platform.' },
           decision: {
             enum: ['approve', 'deny', 'expect'],
@@ -204,6 +217,7 @@ const EVALS_SCHEMA: JsonSchema = {
           { required: ['conversation', 'expected'] },
           { required: ['conversation', 'expectedContains'] },
           { required: ['conversation', 'checks'] },
+          { required: ['conversation', 'notContains'] },
           { required: ['scenario'] },
         ],
         additionalProperties: false,
@@ -308,7 +322,7 @@ const DATASET_SCHEMA: JsonSchema = {
   $schema: DRAFT,
   title: 'Dataset definition (datasets/<apiName>.json)',
   description:
-    'Data the Blueprint reads. kind says where the columns come from: blank declares them, file reads a CSV, source pulls a relation from a connected Source. A key another kind reads is refused.',
+    'Data the Blueprint reads. kind says where the columns come from: blank declares them, file reads a CSV, source pulls a relation from a connected Source. A key another kind reads is refused. A change request carries a dataset as its columns, never its rows: a blank one, or a file one whose `columns` give every included column its databaseType and nullable.',
   type: 'object',
   oneOf: [
     {
@@ -723,6 +737,40 @@ const SECRETS_SCHEMA: JsonSchema = {
   additionalProperties: false,
 }
 
+/** `apps/<slug>.json`, as a pull writes it (`appDocument` in `local-apps.ts`; `appSettingsCandidate` in the service). */
+const APP_SCHEMA: JsonSchema = {
+  $schema: DRAFT,
+  title: 'Custom App (apps/<slug>.json)',
+  description:
+    'What a Custom App is and the Functions it may start. Its code is its own project in apps/<slug>/, deployed with `frontera app deploy`; who may open it and its addresses are set on the platform. `frontera local dev` saves the App by its file name (the slug) and binds the Functions listed; `frontera local sync push` proposes its name, description, icon and Functions, and a Function bound in the workspace that the file no longer lists is unbound when the request is applied. `hosting`, `version`, `routing` and the domains are what the workspace reports, read only here.',
+  type: 'object',
+  properties: {
+    name: { type: 'string', minLength: 1, maxLength: 120, description: 'The App’s name; the file name when absent.' },
+    description: { type: 'string', maxLength: 500 },
+    icon: { type: 'string', pattern: '^[a-z0-9][a-z0-9-]{0,119}$', description: 'An icon from the platform’s set, by name (`chart-bar`); the App’s card shows its first letter when the name is not one. Left out, the App keeps its icon.' },
+    functions: {
+      type: 'array',
+      description: 'Every Function the App may start, through a Function bound to it; the App holds no secrets.',
+      items: {
+        type: 'object',
+        properties: {
+          function: { type: 'string', pattern: refPattern(['function']), description: '`function/<slug>`: functions/<slug>.ts, or one the workspace has.' },
+          enabled: { type: 'boolean', default: true, description: 'false keeps the binding switched off.' },
+        },
+        required: ['function'],
+        additionalProperties: false,
+      },
+    },
+    hosting: { enum: ['external'], description: 'Read only: hosted on its own domain.' },
+    version: { type: 'string', description: 'Read only: the deployment production serves.' },
+    routing: { type: 'string', description: 'Read only.' },
+    connectDomains: { type: 'array', items: { type: 'string' }, description: 'Read only: set in the App’s frontera.config.json.' },
+    resourceDomains: { type: 'array', items: { type: 'string' }, description: 'Read only: set in the App’s frontera.config.json.' },
+  },
+  required: ['name'],
+  additionalProperties: false,
+}
+
 /** The schema this CLI owns for a kind, or null when the service owns it. */
 export function cliSchema(kind: SchemaKind): JsonSchema | null {
   if (kind === 'evals') return EVALS_SCHEMA
@@ -731,6 +779,7 @@ export function cliSchema(kind: SchemaKind): JsonSchema | null {
   if (kind === 'bindings') return BINDINGS_SCHEMA
   if (kind === 'theme') return THEME_SCHEMA
   if (kind === 'chat-app') return CHAT_APP_SCHEMA
+  if (kind === 'app') return APP_SCHEMA
   if (kind === 'knowledge') return KNOWLEDGE_SCHEMA
   if (kind === 'skill') return SKILL_SCHEMA
   if (kind === 'secrets') return SECRETS_SCHEMA

package/src/local/local-seed.ts

@@ -166,7 +166,7 @@ export async function seedLocalRuntime(args: SeedArgs): Promise<LocalCredentials
 }
 
 /** Provider ids the service stores as organization credentials, each with an `apiKey` field. */
-const CREDENTIAL_PROVIDERS = new Set(['anthropic', 'openai', 'openrouter', 'google'])
+const CREDENTIAL_PROVIDERS = new Set(['anthropic', 'openai', 'openrouter', 'google', 'openrouter-web-search'])
 
 /** Embedding defaults by provider, in preference order; the service requires 1536-wide vectors. */
 const EMBEDDING: Array<{ provider: string; model: string }> = [

package/src/local/local-stand-ins.ts

@@ -225,6 +225,50 @@ export async function writeStandIns(root: string, names: string[], ws?: SyncClie
   return out
 }
 
+/**
+ * The Plugin installs a Function's deploy was refused for: its `grants`
+ * name `plugin:<install>:<capability>` and the runtime has no install of
+ * that name (`grant "plugin:crm:createLead" names no plugin install called
+ * "crm" in this workspace`). Read from the deploy's error.
+ */
+export function missingGrantInstalls(output: string): Array<{ install: string; capability: string }> {
+  const out: Array<{ install: string; capability: string }> = []
+  for (const m of output.matchAll(/grant "plugin:([^:"\s]+):([^"\s]+)" names no plugin install called "([^"]+)"/g)) {
+    if (!out.some((g) => g.install === m[1] && g.capability === m[2])) out.push({ install: m[1]!, capability: m[2]! })
+  }
+  return out
+}
+
+/**
+ * A stand-in for a workspace Plugin a Function grants itself (Forge
+ * improvement plan X2; P3 F17, P4 2.7: a pulled Function's grant named an
+ * install the local runtime lacks, so it failed on every apply). Written as
+ * `mcp/<install>.stand-in.json` with the granted capability among its tools,
+ * like the stand-ins a pull writes for built-in connections: the Function
+ * deploys here, and each call it makes says it is not connected. Never one
+ * where the project has the Plugin's own file. A stand-in already there
+ * gains the capability. Returns whether the file changed.
+ */
+export function writeGrantStandIn(root: string, install: string, capabilities: string[]): boolean {
+  if (existsSync(join(root, 'mcp', `${install}.plugin.json`))) return false
+  const before = readStandIn(root, install)
+  const tools = new Map((before?.tools ?? []).map((t) => [t.name, t]))
+  for (const c of capabilities) if (!tools.has(c)) tools.set(c, { name: c, description: `Granted to a Function of this project; answers “not connected” here` })
+  const doc: StandInFile = {
+    standIn: true,
+    connection: before?.connection ?? install,
+    ...(before?.serves ? { serves: before.serves } : {}),
+    note: before?.note ?? NOTE,
+    tools: [...tools.values()].sort((a, b) => a.name.localeCompare(b.name)),
+  }
+  const text = `${JSON.stringify(doc, null, 2)}\n`
+  const path = join(root, standInPath(install))
+  if (existsSync(path) && readFileSync(path, 'utf8') === text) return false
+  mkdirSync(dirname(path), { recursive: true })
+  writeFileSync(path, text)
+  return true
+}
+
 /**
  * The tools a stand-in lists: the connection's, as the workspace listed
  * them, and every tool the project's Agents and workflows name on it (a

package/src/local/local-studio-server.ts

@@ -386,14 +386,20 @@ export function startStudioServer(opts: StudioServerOptions) {
     if (state?.credentials?.workspaceId && !headers.has('x-workspace-id')) {
       headers.set('x-workspace-id', state.credentials.workspaceId)
     }
+    // A page sends the session token it kept (`bearer_token`) itself. After
+    // `frontera local reset` that session is gone, so a session the service
+    // refuses is answered as the owner; an API key or a signed token is not.
+    const kept = headers.get('authorization')?.match(/^Bearer ([A-Za-z0-9]{32})$/)?.[1]
+    const fallback = kept && bearer && kept !== bearer ? bearer : null
+    const hasBody = req.method !== 'GET' && req.method !== 'HEAD'
+    const body = hasBody && fallback ? await req.arrayBuffer() : hasBody ? req.body : undefined
     try {
-      const res = await fetch(target, {
-        method: req.method,
-        headers,
-        body: req.method === 'GET' || req.method === 'HEAD' ? undefined : req.body,
-        redirect: 'manual',
-        duplex: 'half',
-      })
+      const send = () => fetch(target, { method: req.method, headers, body, redirect: 'manual', duplex: 'half' })
+      let res = await send()
+      if (res.status === 401 && fallback) {
+        headers.set('authorization', `Bearer ${fallback}`)
+        res = await send()
+      }
       const out = new Headers(res.headers)
       out.delete('content-encoding')
       out.delete('content-length')

package/src/local/local-supervisor.ts

@@ -37,6 +37,8 @@ import { localEmbeddingsReachable, providerEnv } from './local-keys'
 import { applyProviderSetup, readProviderSetup, rememberSlugs, writeProviderSetup } from './local-providers'
 import type { PortBlock } from './local-ports'
 import { startProcess, stopProcess, waitForHttp } from './local-process'
+import { restartJobs, watchJobs } from './local-jobs'
+import { portAnswers } from './local-component-health'
 import type { LocalProject } from './local-project'
 import { startLocalEmbeddings } from './local-embeddings'
 import { LOCAL_TRACE_KEYS, startLocalTraces } from './local-traces'
@@ -299,6 +301,26 @@ export async function runSupervisor(project: LocalProject, ports: PortBlock, ses
       set(name, { status: 'failed', pid: undefined, detail: `exited with code ${code ?? 'signal'}; see \`frontera local logs ${name}\`` })
     })
   }
+
+  // Watch the jobs engine: one that stops answering is restarted alone, and the runs it lost failed (X2).
+  if (enabled('jobs')) {
+    watchJobs({
+      probe: () => portAnswers(ports.jobs, 3_000),
+      restart: async () => {
+        if (stopping) return
+        const restarted = await restartJobs(project, state, 'it stopped answering, so the supervisor restarted it')
+        set('jobs', { status: 'running', startedAt: new Date().toISOString(), detail: undefined })
+        appendFileSync(logPath(project, 'studio'), `[supervisor] jobs engine restarted in ${restarted.ms} ms${restarted.lost ? `; ${restarted.lost} lost runs marked failed` : ''}${restarted.note ? `; ${restarted.note}` : ''}\n`)
+      },
+      log: (line) => {
+        try {
+          appendFileSync(logPath(project, 'studio'), `[supervisor] ${line}\n`)
+        } catch {
+          // Logging never fails the watch.
+        }
+      },
+    })
+  }
 }
 
 type SetFn = (name: ComponentName, patch: Partial<ComponentState>) => void

package/src/local/local-sync-models.ts

@@ -63,6 +63,8 @@ export interface ProjectModels {
   workspace: Set<string> | null
   /** The workspace's models by slug, for words. */
   names: Record<string, string>
+  /** The workspace's evaluation datasets hold conversations of several turns (its `evaluation-conversations` capability, L3). */
+  conversations?: boolean
 }
 
 const cached = new Map<string, { stamp: string; value: ProjectModels }>()
@@ -84,10 +86,11 @@ export function projectModels(root: string): ProjectModels {
   const stamp = stampOf(...files)
   const known = cached.get(root)
   if (known && known.stamp === stamp) return known.value
-  const remote = readJson<{ models?: CatalogEntry[]; names?: { model?: Record<string, string> } }>(join(root, REMOTE_JSON))
+  const remote = readJson<{ models?: CatalogEntry[]; names?: { model?: Record<string, string> }; capabilities?: string[] }>(join(root, REMOTE_JSON))
   const theirs = remote?.models ?? Object.keys(remote?.names?.model ?? {}).map((slug) => ({ slug }) as CatalogEntry)
   const ours = readJson<{ models?: CatalogEntry[] }>(join(root, LOCAL_CATALOG))?.models ?? []
-  const value = matchModels(ours, theirs.length ? theirs : null, modelMap(root))
+  const matched = matchModels(ours, theirs.length ? theirs : null, modelMap(root))
+  const value = remote?.capabilities?.includes('evaluation-conversations') ? { ...matched, conversations: true } : matched
   cached.set(root, { stamp, value })
   return value
 }

package/src/local/local-sync-names.ts

@@ -114,6 +114,7 @@ export function namingPaths(kind: string, name: string): string[] {
   if (kind === 'chat-app') return [`chat-apps/${name}.json`]
   if (kind === 'app') return [`apps/${name}.json`]
   if (kind === 'knowledge') return [`knowledge/${name}/knowledge.json`]
+  if (kind === 'dataset') return [`datasets/${name}.json`]
   return []
 }
 
@@ -139,6 +140,8 @@ export function itemTitle(kind: string, name: string, files: Record<string, stri
     const own = yamlField(file, 'displayName') ?? declared(parseJson(file), 'displayName')
     return own ?? (dir === 'object-sets' ? readableName(apiName ?? name) : (apiName ?? name))
   }
+  // A dataset by its display name, else its API name as object types name it.
+  if (kind === 'dataset') return declared(parseJson(files[`datasets/${name}.json`]), 'displayName') ?? name
   if (kind === 'skill') {
     const own = yamlField(files[`skills/${name}/SKILL.md`], 'displayName')
     if (own) return own